Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Utilizzo delle query dirette OpenSearch di Amazon Service Usa la query diretta di Amazon OpenSearch Service per analizzare i dati in Amazon CloudWatch Logs, Amazon S3, Amazon Security Lake e Amazon Managed Service for Prometheus senza creare pipeline di ingestione. **Questa integrazione zero-ETL ti consente di interrogare i dati sul posto utilizzando ProMQL, PPL o SQL ed esplorarli in Discover.** [Per iniziare a usare Amazon Managed Service for Prometheus CloudWatch , Logs o Security Lake, configura la tua origine dati nella console di gestione.AWS](https://console.aws.amazon.com/aos/home#opensearch/data-sources) Per Amazon S3, usa connessioni di dominio e crea tabelle con SQL in Query Workbench. CloudWatch Logs e Security Lake utilizzano sorgenti di dati e schemi preconfigurati. Per Amazon S3 e Security Lake, i dati vengono catalogati utilizzando AWS Glue Data Catalog tabelle: Amazon S3 richiede di creare queste tabelle manualmente, mentre Security Lake le configura automaticamente come parte del processo di inserimento. # Interrogazione diretta dei dati di Amazon S3 in Service OpenSearch Questa sezione ti illustrerà il processo di creazione e configurazione di un'integrazione di origini dati in Amazon OpenSearch Service, consentendoti di interrogare e analizzare in modo efficiente i dati archiviati in Amazon S3. Nelle pagine seguenti, imparerai come configurare un'origine dati con query diretta di Amazon S3, esplorare i prerequisiti necessari e seguire le step-by-step procedure utilizzando sia l'API che quella del Console di gestione AWS servizio. OpenSearch Descrive anche importanti passaggi successivi, tra cui la mappatura dei AWS Glue Data Catalog ruoli e la configurazione dei controlli di accesso nelle dashboard. OpenSearch **Topics** + [Creazione di un'integrazione dell'origine dati Amazon S3 in Service OpenSearch](direct-query-s3-creating.md) + [Configurazione e interrogazione di un'origine dati S3 nei dashboard OpenSearch](direct-query-s3-configure.md) + [Prezzi](#direct-query-s3-pricing) + [Limitazioni](#direct-query-s3-limitations) + [Raccomandazioni](#direct-query-s3-recommendations) + [Quote](#direct-query-s3-quotas) + [Supportato Regioni AWS](#direct-query-s3-regions) # Creazione di un'integrazione dell'origine dati Amazon S3 in Service OpenSearch Puoi creare una nuova origine dati Amazon S3 a query diretta per OpenSearch Service tramite o l' Console di gestione AWS API. Ogni nuova fonte di dati utilizza AWS Glue Data Catalog per gestire le tabelle che rappresentano i bucket Amazon S3. **Topics** + [Prerequisiti](#direct-query-s3-prereq) + [Procedura](#direct-query-s3-create) + [Fasi successive](#direct-query-s3-next-steps) + [Mappa il ruolo AWS Glue Data Catalog](#direct-query-s3-permissions) + [Risorse aggiuntive](#direct-query-s3-additional-resources) ## Prerequisiti Prima di iniziare, assicurati di aver letto la seguente documentazione: + [Limitazioni](direct-query-s3-overview.md#direct-query-s3-limitations) + [Raccomandazioni](direct-query-s3-overview.md#direct-query-s3-recommendations) + [Quote](direct-query-s3-overview.md#direct-query-s3-quotas) Prima di poter creare un'origine dati, devi disporre delle seguenti risorse Account AWS: + **Un OpenSearch dominio con versione 2.13 o successiva.** Questa è la base per configurare l'integrazione delle query dirette. Per istruzioni sulla configurazione, consulta[Creazione OpenSearch di domini di servizio](createupdatedomains.md#createdomains). + **Uno o più bucket S3.** Dovrai specificare i bucket contenenti i dati che desideri interrogare e un bucket in cui archiviare i checkpoint delle query. Per istruzioni sulla creazione di un bucket S3, consulta [Creare un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) nella guida per l'utente di Amazon S3. + **(Facoltativo) Una o più tabelle. AWS Glue **L'interrogazione dei dati su Amazon S3 richiede che le tabelle siano configurate AWS Glue Data Catalog in modo che puntino ai dati S3. È necessario creare le tabelle utilizzando OpenSearch Query Workbench. Le tabelle Hive esistenti non sono compatibili. Se è la prima volta che configuri un'origine dati Amazon S3, devi creare un'origine dati di amministrazione per configurare tutte le AWS Glue Data Catalog tabelle. Puoi farlo installando OpenSearch out-of-the-box integrazioni o utilizzando OpenSearch Query Workbench per creare tabelle SQL personalizzate per casi d'uso avanzati. [Per esempi sulla creazione di tabelle per VPC e log AWS WAF, consulta la documentazione su GitHub VPC e. CloudTrail [CloudTrail[AWS WAF](https://github.com/opensearch-project/opensearch-catalog/blob/main/integrations/observability/aws_waf/assets/create_table-1.0.0.sql)](https://github.com/opensearch-project/opensearch-catalog/blob/main/integrations/observability/aws_cloudtrail/assets/create_table_cloud-trail-records-1.0.0.sql)](https://github.com/opensearch-project/opensearch-catalog/blob/main/integrations/observability/amazon_vpc_flow/assets/create_table_vpc_schema-1.0.0.sql) Dopo aver creato le tabelle, puoi creare nuove fonti di dati Amazon S3 e limitare l'accesso a tabelle limitate. + **(Facoltativo) Un ruolo IAM creato manualmente.**Puoi utilizzare questo ruolo per gestire l'accesso alla tua fonte di dati. In alternativa, puoi fare in modo che OpenSearch Service crei automaticamente un ruolo per te con le autorizzazioni richieste. Se scegli di utilizzare un ruolo IAM creato manualmente, segui le indicazioni riportate in[Autorizzazioni richieste per i ruoli IAM creati manualmente](#direct-query-s3-additional-resources-required-permissions). ## Procedura Puoi configurare un'origine dati con interrogazione diretta su un dominio con Console di gestione AWS o l'API OpenSearch Service. ### Per configurare una fonte di dati utilizzando il Console di gestione AWS 1. Accedi alla console di Amazon OpenSearch Service all'indirizzo[https://console.aws.amazon.com/aos/](https://console.aws.amazon.com/aos/). 1. Nel riquadro di navigazione a sinistra, scegli **Domains** (Domini). 1. Seleziona il dominio per cui desideri configurare una nuova fonte di dati. Si apre la pagina dei dettagli del dominio. 1. Scegli la scheda **Connessioni** sotto i dettagli generali del dominio e trova la sezione **Direct Query**. 1. Scegli **Configura origine dati**. 1. Inserisci un nome e una descrizione opzionale per la tua nuova fonte di dati. 1. Scegli **Amazon S3 con**. AWS Glue Data Catalog 1. In **Impostazioni di accesso tramite autorizzazione IAM**, scegli come gestire l'accesso. 1. Se desideri creare automaticamente un ruolo per questa fonte di dati, segui questi passaggi: 1. Seleziona **Crea un nuovo ruolo**. 1. Inserire un nome per il ruolo IAM. 1. Seleziona uno o più bucket S3 che contengono i dati da interrogare. 1. Seleziona un bucket S3 di checkpoint in cui archiviare i checkpoint delle query. 1. Seleziona uno o più AWS Glue database o tabelle per definire quali dati possono essere interrogati. Se le tabelle non sono ancora state create, fornisci l'accesso al database predefinito. 1. Se desideri utilizzare un ruolo esistente che gestisci tu stesso, segui questi passaggi: 1. Seleziona **Utilizza un ruolo esistente**. 1. Seleziona un ruolo esistente dal menu a discesa. **Nota** Quando utilizzi il tuo ruolo, devi assicurarti che disponga di tutte le autorizzazioni necessarie allegando le policy richieste dalla console IAM. Per ulteriori informazioni, consulta la policy di esempio in. [Autorizzazioni richieste per i ruoli IAM creati manualmente](#direct-query-s3-additional-resources-required-permissions) 1. Scegli **Configura**. Si apre la schermata dei dettagli dell'origine dati con un URL del OpenSearch pannello di controllo. Puoi accedere a questo URL per completare i passaggi successivi. ### OpenSearch API di servizio Usa l'operazione [AddDataSource](https://docs.aws.amazon.com/opensearch-service/latest/APIReference/API_AddDataSource.html)API per creare una nuova fonte di dati nel tuo dominio. ``` POST https://es.region.amazonaws.com/2021-01-01/opensearch/domain/domain-name/dataSource { "DataSourceType": { "S3GlueDataCatalog": { "RoleArn": "arn:aws:iam::account-id:role/role-name" } } "Description": "data-source-description", "Name": "my-data-source" } ``` ## Fasi successive ### Visita OpenSearch Dashboards Dopo aver creato un'origine dati, OpenSearch Service ti fornisce un link OpenSearch Dashboards. Puoi usarlo per configurare il controllo degli accessi, definire tabelle, installare out-of-the-box integrazioni e interrogare i tuoi dati. Per ulteriori informazioni, consulta [Configurazione e interrogazione di un'origine dati S3 nei dashboard OpenSearch](direct-query-s3-configure.md). ## Mappa il ruolo AWS Glue Data Catalog Se hai abilitato il [controllo granulare degli accessi](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/fgac.html) dopo aver creato un'origine dati, devi mappare gli utenti non amministratori a un ruolo IAM con AWS Glue Data Catalog accesso per eseguire query dirette. Per creare manualmente un ruolo di back-end che puoi mappare al `glue_access` ruolo IAM, esegui i seguenti passaggi: **Nota** Gli indici vengono utilizzati per qualsiasi interrogazione sulla fonte di dati. Un utente con accesso in lettura all'indice delle richieste per una determinata origine dati può leggere *tutte le* query relative a tale origine dati. Un utente con accesso in lettura all'indice dei risultati può leggere i risultati di *tutte* le query eseguite su quell'origine dati. 1. Dal menu principale di OpenSearch Dashboard, scegli **Sicurezza**, **Ruoli e **Crea** ruoli**. 1. Assegna un nome al ruolo **glue\$1access**. 1. Per le **autorizzazioni del cluster**, seleziona`indices:data/write/bulk*`,. `indices:data/read/scroll` `indices:data/read/scroll/clear` 1. Per **Indice**, inserisci i seguenti indici a cui desideri concedere all'utente con il ruolo l'accesso: + `.query_execution_request_` + `query_execution_result_` + `.async-query-scheduler` + `flint_*` 1. Per le **autorizzazioni di indicizzazione**, seleziona. `indices_all` 1. Scegli **Create** (Crea). 1. Scegliere **Utenti mappati**, **Gestisci mappatura**. 1. In **Ruoli di backend**, aggiungi l'ARN del ruolo che richiede AWS Glue l'autorizzazione per chiamare il tuo dominio. ``` arn:aws:iam::account-id:role/role-name ``` 1. Seleziona **Mappa** e conferma che il ruolo sia visualizzato in Utenti **mappati**. Per ulteriori informazioni sulla mappatura dei ruoli, vedere. [Mappatura dei ruoli agli utenti](fgac.md#fgac-mapping) ## Risorse aggiuntive ### Autorizzazioni richieste per i ruoli IAM creati manualmente Quando crei un'origine dati per il tuo dominio, scegli un ruolo IAM per gestire l'accesso ai tuoi dati. Sono disponibili due opzioni: 1. Crea automaticamente un nuovo ruolo IAM 1. Utilizza un ruolo IAM esistente che hai creato manualmente Se utilizzi un ruolo creato manualmente, devi assegnare le autorizzazioni corrette al ruolo. Le autorizzazioni devono consentire l'accesso alla fonte di dati specifica e consentire a OpenSearch Service di assumere il ruolo. Ciò è necessario affinché il OpenSearch Servizio possa accedere e interagire in modo sicuro con i dati dell'utente. La seguente politica di esempio illustra le autorizzazioni con privilegi minimi necessarie per creare e gestire un'origine dati. Se disponi di autorizzazioni più ampie, ad esempio `s3:*` o la policy, queste autorizzazioni comprendono le autorizzazioni con il `AdminstratorAccess` privilegio minimo della politica di esempio. Nella seguente politica di esempio, sostituiscila con le tue informazioni. *placeholder text * ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Sid":"HttpActionsForOpenSearchDomain", "Effect":"Allow", "Action":"es:ESHttp*", "Resource":"arn:aws:es:us-east-1:111122223333:domain/example.com/*" }, { "Sid":"AmazonOpenSearchS3GlueDirectQueryReadAllS3Buckets", "Effect":"Allow", "Action":[ "s3:GetObject", "s3:GetObjectVersion", "s3:ListBucket" ], "Condition":{ "StringEquals":{ "aws:ResourceAccount":"111122223333" } }, "Resource":"*" }, { "Sid":"AmazonOpenSearchDirectQueryGlueCreateAccess", "Effect":"Allow", "Action":[ "glue:CreateDatabase", "glue:CreatePartition", "glue:CreateTable", "glue:BatchCreatePartition" ], "Resource":"*" }, { "Sid":"AmazonOpenSearchS3GlueDirectQueryModifyAllGlueResources", "Effect":"Allow", "Action":[ "glue:DeleteDatabase", "glue:DeletePartition", "glue:DeleteTable", "glue:GetDatabase", "glue:GetDatabases", "glue:GetPartition", "glue:GetPartitions", "glue:GetTable", "glue:GetTableVersions", "glue:GetTables", "glue:UpdateDatabase", "glue:UpdatePartition", "glue:UpdateTable", "glue:BatchGetPartition", "glue:BatchDeletePartition", "glue:BatchDeleteTable" ], "Resource":[ "arn:aws:glue:us-east-1:111122223333:table/*", "arn:aws:glue:us-east-1:111122223333:database/*", "arn:aws:glue:us-east-1:111122223333:catalog", "arn:aws:es:us-east-1:111122223333:domain/domain_name" ], "Condition":{ "StringEquals":{ "aws:ResourceAccount":"111122223333" } } }, { "Sid":"ReadAndWriteActionsForS3CheckpointBucket", "Effect":"Allow", "Action":[ "s3:ListMultipartUploadParts", "s3:DeleteObject", "s3:GetObject", "s3:PutObject", "s3:GetBucketLocation", "s3:ListBucket" ], "Condition":{ "StringEquals":{ "aws:ResourceAccount":"111122223333" } }, "Resource":[ "arn:aws:s3:::amzn-s3-demo-bucket", "arn:aws:s3:::amzn-s3-demo-bucket/*" ] } ] } ``` ------ Per supportare i bucket Amazon S3 in diversi account, dovrai includere una condizione nella policy di Amazon S3 e aggiungere l'account appropriato. Nella seguente condizione di esempio, sostituiscila *placeholder text * con le tue informazioni. ``` "Condition": { "StringEquals": { "aws:ResourceAccount": "{{accountId}}" } ``` Il ruolo deve inoltre avere la seguente politica di fiducia, che specifica l'ID di destinazione. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Principal":{ "Service": "directquery.opensearchservice.amazonaws.com" }, "Action":"sts:AssumeRole" } ] } ``` ------ Per istruzioni sulla creazione del ruolo, consulta [Creazione di un ruolo utilizzando policy di attendibilità personalizzate](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html). Se hai abilitato il controllo granulare degli accessi in OpenSearch Service, verrà creato automaticamente un nuovo ruolo di controllo OpenSearch degli accessi granulare per la tua fonte di dati. Il nome del nuovo ruolo di controllo degli accessi a grana fine sarà. `AWS OpenSearchDirectQuery ` Per impostazione predefinita, il ruolo ha accesso solo agli indici delle fonti di dati di interrogazione diretta. Sebbene sia possibile configurare il ruolo per limitare o concedere l'accesso all'origine dati, si consiglia di non modificare l'accesso di questo ruolo. **Se elimini l'origine dati, questo ruolo verrà eliminato**. Ciò rimuoverà l'accesso per tutti gli altri utenti se sono mappati al ruolo. # Configurazione e interrogazione di un'origine dati S3 nei dashboard OpenSearch Ora che hai creato la tua origine dati, puoi configurare le impostazioni di sicurezza, definire le tabelle Amazon S3 o configurare l'indicizzazione accelerata dei dati. Questa sezione illustra vari casi d'uso con la tua fonte di dati nelle OpenSearch dashboard prima di interrogare i dati. Per configurare le seguenti sezioni, devi prima accedere alla tua origine dati in OpenSearch Dashboards. **Nella barra di navigazione a sinistra, in **Gestione**, scegli Origini dati.** In **Gestisci fonti di dati**, seleziona il nome dell'origine dati che hai creato nella console. ## Crea tabelle Spark utilizzando Query Workbench Le query dirette dal OpenSearch Servizio ad Amazon S3 utilizzano le tabelle Spark all'interno di. AWS Glue Data Catalog Puoi creare tabelle dall'interno di Query Workbench senza dover uscire dai dashboard. OpenSearch Per gestire database e tabelle esistenti nella tua origine dati o per creare nuove tabelle su cui desideri utilizzare le **query dirette, scegli Query Workbench** dalla barra di navigazione a sinistra e seleziona l'origine dati Amazon S3 dal menu a discesa delle origini dati. Per impostare una tabella per i log di flusso VPC archiviati in S3 in formato Parquet, esegui la seguente query: ``` CREATE TABLE datasourcename.gluedatabasename.vpclogstable (version INT, account_id STRING, interface_id STRING, srcaddr STRING, dstaddr STRING, srcport INT, dstport INT, protocol INT, packets BIGINT, bytes BIGINT, start BIGINT, end BIGINT, action STRING, log_status STRING, `aws-account-id` STRING, `aws-service` STRING, `aws-region` STRING, year STRING, month STRING, day STRING, hour STRING) USING parquet PARTITIONED BY (aws-account-id, aws-service, aws-region, year, month, day, hour) LOCATION "s3://accountnum-vpcflow/AWSLogs" ``` Dopo aver creato la tabella, esegui la seguente query per assicurarti che sia compatibile con le query dirette: ``` MSCK REPAIR TABLE datasourcename.databasename.vpclogstable ``` ## Imposta le integrazioni per i tipi di log più diffusi AWS Puoi integrare i tipi di AWS log archiviati in Amazon S3 con OpenSearch Service. Usa OpenSearch le dashboard per installare integrazioni che creano AWS Glue Data Catalog tabelle, query salvate e dashboard. Queste integrazioni utilizzano viste indicizzate per mantenere aggiornate le dashboard. Per istruzioni sull'installazione di un'integrazione, consulta [Installazione di una risorsa di integrazione](https://opensearch.org/docs/latest/integrations/#installing-an-integration-asset) nella documentazione. OpenSearch Quando selezioni un'integrazione, assicurati che abbia il `S3 Glue` tag. Quando configuri l'integrazione, specifica **S3 Connection** per il tipo di connessione. Quindi, seleziona l'origine dati per l'integrazione, la posizione dei dati in Amazon S3, il checkpoint per gestire l'indicizzazione dell'accelerazione e gli asset necessari per il tuo caso d'uso. **Nota** Assicurati che il bucket S3 per il checkpoint disponga delle autorizzazioni di scrittura per la posizione del checkpoint. Senza queste autorizzazioni, le accelerazioni dell'integrazione falliranno. ## Configurazione del controllo degli accessi **Nella pagina dei dettagli della tua origine dati, trova la sezione **Controlli di accesso** e scegli Modifica.** Se il dominio ha abilitato il controllo granulare degli accessi, scegli **Restricted** e seleziona i ruoli a cui desideri fornire l'accesso alla nuova fonte di dati. Puoi anche scegliere **Amministratore solo** se desideri che solo l'amministratore abbia accesso all'origine dati. **Importante** Gli indici vengono utilizzati per qualsiasi interrogazione sull'origine dati. Un utente con accesso in lettura all'indice delle richieste per una determinata origine dati può leggere *tutte le* query relative a tale origine dati. Un utente con accesso in lettura all'indice dei risultati può leggere i risultati di *tutte* le query eseguite su quell'origine dati. ## Interrogazione dei dati S3 in Discover OpenSearch Dopo aver impostato le tabelle e configurato l'accelerazione delle query opzionale desiderata, puoi iniziare ad analizzare i dati. Per interrogare i dati, seleziona la fonte dei dati dal menu a discesa. Se utilizzi Amazon S3 e OpenSearch Dashboards, vai su Discover e seleziona il nome dell'origine dati. Se utilizzi un indice ignorante o non hai ancora creato un indice, puoi usare SQL o PPL per interrogare i tuoi dati. Se hai configurato una vista materializzata o un indice di copertura, disponi già di un indice e puoi utilizzare Dashboards Query Language (DQL) in tutte le dashboard. Puoi anche usare PPL con il plug-in Observability e SQL con il plug-in Query Workbench. Attualmente, solo i plugin Observability e Query Workbench supportano PPL e SQL. [Per interrogare i dati utilizzando l'API di OpenSearch servizio, consulta la documentazione dell'API asincrona.](https://github.com/opensearch-project/sql/blob/main/docs/user/interfaces/asyncqueryinterface.rst) **Nota** Non tutte le istruzioni, i comandi e le funzioni SQL e PPL sono supportati. Per un elenco dei comandi supportati, vedere[Comandi SQL e PPL supportati](direct-query-supported-commands.md). Se hai creato una vista materializzata o un indice di copertura, puoi usare DQL per interrogare i tuoi dati, purché li abbia indicizzati all'interno. ## Risoluzione dei problemi In alcuni casi i risultati non vengono restituiti come previsto. In caso di problemi, assicurati di seguire il[Raccomandazioni](direct-query-s3-overview.md#direct-query-s3-recommendations). ## Prezzi Amazon OpenSearch Service offre prezzi OpenSearch Compute Unit (OCU) per le query dirette su Amazon S3. Quando esegui le query dirette, ti vengono addebitati addebiti orari, indicati nella fattura come OCUs DirectQuery tipo di utilizzo dell'OCU. Saranno inoltre addebitati costi separati da Amazon S3 per lo storage dei dati. Le query dirette sono di due tipi: interattive e con visualizzazione indicizzata. + *Le query interattive* vengono utilizzate per compilare il selettore di dati ed eseguire analisi sui dati in Amazon S3. Quando esegui una nuova query da Discover, OpenSearch Service avvia una nuova sessione che dura almeno tre minuti. OpenSearch Il servizio mantiene attiva questa sessione per garantire che le query successive vengano eseguite rapidamente. + Le *query di visualizzazione indicizzata* utilizzano il calcolo per mantenere le viste indicizzate nel Servizio. OpenSearch Queste query in genere richiedono più tempo perché inseriscono una quantità variabile di dati in un indice denominato. Per le origini dati Amazon S3, i dati indicizzati vengono archiviati in un dominio in base al tipo di istanza acquistato. Per ulteriori informazioni, consulta le sezioni Direct Query e Serverless all'interno [dei prezzi OpenSearch di Amazon Service](https://aws.amazon.com/opensearch-service/pricing/). ## Limitazioni Le seguenti limitazioni si applicano alle query dirette in Amazon S3: + La query diretta per S3 è disponibile solo nei domini di OpenSearch servizio che eseguono la OpenSearch versione 2.13 o successiva e richiede l'accesso a. AWS Glue Data Catalog AWS Glue Data Catalog Le tabelle esistenti devono essere ricreate utilizzando SQL in Query Workbench. OpenSearch + Direct Query for S3 richiede di specificare un bucket di checkpoint su Amazon S3. Questo bucket mantiene lo stato delle viste indicizzate, inclusa l'ora dell'ultimo aggiornamento e i dati inseriti più di recente. + Il tuo OpenSearch dominio deve appartenere allo stesso. AWS Glue Data Catalog Account AWS Il tuo bucket S3 può trovarsi in un account diverso (richiede l'aggiunta di una condizione alla tua policy IAM), ma deve appartenere allo Regione AWS stesso dominio. + OpenSearch Le query Service Direct con S3 supportano solo le tabelle Spark generate da Query Workbench. Le tabelle generate all'interno di AWS Glue Data Catalog o Athena non sono supportate dallo streaming Spark, necessario per mantenere le viste indicizzate. + OpenSearch i tipi di istanza hanno limiti di payload in rete di 10 MiB o 100 MiB, a seconda del tipo di istanza specifico scelto. + Alcuni tipi di dati non sono supportati. I tipi di dati supportati sono limitati a Parquet, CSV e JSON. + Se la struttura dei dati cambia nel tempo, dovrai aggiornare le viste o le out-of-the-box integrazioni indicizzate per tenere conto delle modifiche alla struttura dei dati. + AWS CloudFormation i modelli non sono ancora supportati. + OpenSearch Le istruzioni SQL e OpenSearch PPL presentano limitazioni diverse quando si lavora con OpenSearch gli indici rispetto all'utilizzo di query dirette. Direct Query supporta comandi avanzati come JOINs sottoquery e ricerche, mentre il supporto per questi comandi sugli OpenSearch indici è limitato o inesistente. Per ulteriori informazioni, consulta [Comandi SQL e PPL supportati](direct-query-supported-commands.md). ## Raccomandazioni Per l'utilizzo di query dirette in Amazon S3, consigliamo quanto segue: + Inserisci dati in Amazon S3 utilizzando i formati di partizione di anno, mese, giorno e ora per velocizzare le query. + Quando crei indici ignoranti, usa i filtri Bloom per i campi con cardinalità elevata e min/max gli indici per i campi con intervalli di valori ampi. Per i campi ad alta cardinalità, prendi in considerazione l'utilizzo di un approccio basato sui valori per migliorare l'efficienza delle query. + Utilizzate Index State Management per mantenere lo spazio di archiviazione per le viste materializzate e gli indici di copertura. + Utilizzate la `COALESCE SQL` funzione per gestire le colonne mancanti e assicurarvi che i risultati vengano restituiti. + Usa i limiti per le tue query per assicurarti di non recuperare troppi dati. ## Quote Ogni volta che si avvia una query su un'origine dati Amazon S3 OpenSearch , Service apre *una* sessione e la mantiene attiva per almeno tre minuti. Ciò riduce la latenza delle query eliminando il tempo di avvio della sessione nelle query successive. | Description | Massimo | Può sovrascrivere | | --- | --- | --- | | Connessioni per dominio | 10 | Sì | | Fonti di dati per dominio | 20 | Sì | | Indici per dominio | 5 | Sì | | Sessioni simultanee per origine dati | 10 | Sì | | Numero massimo di OCU per query | 60 | Sì | | Tempo massimo di esecuzione della query (minuti) | 30 | Sì | | Massimo OCUs per accelerazione | 20 | Sì | | Archiviazione effimera massima | 20 | Sì | ## Supportato Regioni AWS Quanto segue Regioni AWS è supportato per le query dirette in Amazon S3: + Asia Pacifico (Hong Kong) + Asia Pacifico (Mumbai) + Asia Pacifico (Seoul) + Asia Pacifico (Singapore) + Asia Pacifico (Sydney) + Asia Pacifico (Tokyo) + Canada (Centrale) + Europa (Francoforte) + Europa (Irlanda) + Europa (Stoccolma) + Stati Uniti orientali (Virginia settentrionale) + Stati Uniti orientali (Ohio) + Stati Uniti occidentali (Oregon) # Interrogazione diretta dei dati di Amazon CloudWatch Logs in Service OpenSearch Questa sezione ti illustrerà il processo di creazione e configurazione di un'integrazione di fonti di dati in Amazon OpenSearch Service, consentendoti di interrogare e analizzare in modo efficiente i dati archiviati nei CloudWatch log. Nelle pagine seguenti, imparerai come configurare un'origine dati CloudWatch Logs con interrogazione diretta, esplorare i prerequisiti necessari e seguire le procedure utilizzando. step-by-step Console di gestione AWS **Topics** + [Creazione di un'integrazione dell'origine dati Amazon CloudWatch Logs in Service OpenSearch](direct-query-cloudwatch-logs-creating.md) + [Configurazione e interrogazione di un'origine dati CloudWatch Logs nei dashboard OpenSearch](direct-query-cloudwatch-logs-configure.md) + [Prezzi](#direct-query-cloudwatch-logs-pricing) + [Limitazioni](#direct-query-cloudwatch-logs-limitations) + [Raccomandazioni](#direct-query-cloudwatch-logs-recommendations) + [Quote](#direct-query-cloudwatch-logs-quotas) + [Supportato Regioni AWS](#direct-query-cloudwatch-logs-regions) # Creazione di un'integrazione dell'origine dati Amazon CloudWatch Logs in Service OpenSearch Se utilizzi Amazon OpenSearch Serverless per le tue esigenze di osservabilità, ora puoi analizzare i tuoi Amazon CloudWatch Logs senza copiare o importare i dati in Service. OpenSearch Questa funzionalità sfrutta l'interrogazione diretta per l'interrogazione dei dati, in modo simile all'analisi dei dati in Amazon S3 from Service. OpenSearch Puoi iniziare creando una nuova fonte di dati connessa dalla console di gestione. AWS Puoi creare una nuova fonte di dati per analizzare i dati di CloudWatch Logs senza dover creare Amazon OpenSearch Serverless per interrogare direttamente i log operativi in Logs. CloudWatch Ciò consente di analizzare i dati operativi a cui si accede e che si trovano al di fuori del Servizio. OpenSearch Eseguendo interrogazioni tra OpenSearch Service e CloudWatch Logs, è possibile iniziare ad analizzare i log in CloudWatch Logs e poi tornare al monitoraggio delle fonti di dati senza dover cambiare strumento. OpenSearch Per utilizzare questa funzionalità, è necessario creare un'origine dati CloudWatch Logs Direct Query per OpenSearch Service tramite la Console di gestione. AWS **Topics** + [Prerequisiti](#direct-query-cloudwatch-logs-prereq) + [Procedura](#direct-query-cloudwatch-logs-create) + [Fasi successive](#direct-query-cloudwatch-logs-next-steps) + [Altre risorse](#direct-query-cloudwatch-logs-additional-resources) ## Prerequisiti Prima di iniziare, assicurati di aver letto la seguente documentazione: + [Limitazioni](direct-query-cloudwatch-logs-overview.md#direct-query-cloudwatch-logs-limitations) + [Raccomandazioni](direct-query-cloudwatch-logs-overview.md#direct-query-cloudwatch-logs-recommendations) + [Quote](direct-query-cloudwatch-logs-overview.md#direct-query-cloudwatch-logs-quotas) Prima di poter creare un'origine dati, devi disporre delle seguenti risorse Account AWS: + **Abilita CloudWatch i registri.** Configura CloudWatch Logs per raccogliere i log sulla Account AWS stessa risorsa. OpenSearch Per istruzioni, consulta [Getting started with CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_GettingStarted.html) nella guida per l'utente di Amazon CloudWatch Logs. + **Uno o più gruppi di CloudWatch log.**È possibile specificare i gruppi di log contenenti i dati che si desidera interrogare. Per istruzioni sulla creazione di un gruppo di log, consulta [Creare un gruppo di log in CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html) nella guida per l'utente di Amazon CloudWatch Logs. + **(Facoltativo) Un ruolo IAM creato manualmente.**Puoi utilizzare questo ruolo per gestire l'accesso alla tua fonte di dati. In alternativa, puoi fare in modo che OpenSearch Service crei automaticamente un ruolo per te con le autorizzazioni richieste. Se scegli di utilizzare un ruolo IAM creato manualmente, segui le indicazioni riportate in[Autorizzazioni richieste per i ruoli IAM creati manualmente](#direct-query-cloudwatch-logs-additional-resources-required-permissions). ## Procedura Puoi configurare un'origine dati di interrogazione a livello di raccolta con. Console di gestione AWS ### Per configurare un'origine dati a livello di raccolta utilizzando il Console di gestione AWS 1. Accedi alla console di Amazon OpenSearch Service all'indirizzo[https://console.aws.amazon.com/aos/](https://console.aws.amazon.com/aos/). 1. Nel riquadro di navigazione a sinistra, vai a **Gestione centrale** e scegli **Origini dati connesse**. 1. Scegli **Connetti**. 1. Scegli **CloudWatch**come tipo di origine dati. 1. Scegli **Next (Successivo)**. 1. In **Dettagli della connessione dati**, inserisci un nome e una descrizione opzionale. 1. In **Ruoli IAM**, scegli come gestire l'accesso ai gruppi di log. 1. Se desideri creare automaticamente un ruolo per questa fonte di dati, segui questi passaggi: 1. Seleziona **Crea un nuovo ruolo**. 1. Inserire un nome per il ruolo IAM. 1. Seleziona uno o più gruppi di log per definire quali dati possono essere interrogati. 1. Se desideri utilizzare un ruolo esistente che gestisci tu stesso, segui questi passaggi: 1. Seleziona **Utilizza un ruolo esistente**. 1. Seleziona un ruolo esistente dal menu a discesa. **Nota** Quando utilizzi il tuo ruolo, devi assicurarti che disponga di tutte le autorizzazioni necessarie allegando le policy richieste dalla console IAM. Per ulteriori informazioni, consulta [Autorizzazioni richieste per i ruoli IAM creati manualmente](#direct-query-cloudwatch-logs-additional-resources-required-permissions). 1. (Facoltativo) In **Politica di accesso**, configura una politica di accesso per l'origine dati. Le politiche di accesso controllano se una richiesta all'origine dati OpenSearch di Service Direct Query viene accettata o rifiutata. Se non configuri una politica di accesso, solo il proprietario dell'origine dati può accedervi. Puoi configurare la politica di accesso per abilitare l'accesso tra più account, consentendo ai responsabili di altri di accedere Account AWS alla fonte di dati. È possibile creare una politica di accesso utilizzando l'editor visivo o fornendo un documento di policy JSON. Con l'editor visivo, puoi consentire o negare l'accesso specificando un Account AWS ID principale, l'ARN dell'account, l'ARN dell'utente IAM, l'ARN del ruolo IAM, l'indirizzo IP di origine o il blocco CIDR. L'editor visivo supporta fino a 10 elementi. Per definire una policy con più di 10 elementi, usa l'editor JSON. Puoi anche scegliere **Importa policy per importare** una politica di accesso esistente da un'altra fonte di dati. 1. (Facoltativo) In **Tag**, aggiungi tag alla tua fonte di dati. 1. Scegli **Next (Successivo)**. 1. In **Configurazione OpenSearch**, scegli come eseguire la configurazione OpenSearch. 1. Usa le impostazioni predefinite: 1. Rivedi i nomi delle risorse predefiniti e le impostazioni di conservazione dei dati. Ti consigliamo di utilizzare nomi personalizzati. Quando utilizzi le impostazioni predefinite, vengono create automaticamente una nuova OpenSearch applicazione e un'area di lavoro Essentials senza costi aggiuntivi. OpenSearch consente di analizzare più fonti di dati. Include aree di lavoro, che offrono esperienze personalizzate per i casi d'uso più diffusi. Le aree di lavoro supportano il controllo degli accessi, consentendoti di creare spazi privati per i tuoi casi d'uso e condividerli solo con i tuoi collaboratori. 1. Usa impostazioni personalizzate: 1. Scegliere **Customize (Personalizza)**. 1. Modifica il nome della raccolta e le impostazioni di conservazione dei dati secondo necessità. 1. Seleziona l' OpenSearch applicazione e l'area di lavoro che desideri utilizzare. 1. Scegli **Next (Successivo)**. 1. Rivedi le tue scelte e scegli **Modifica** se devi apportare modifiche. 1. Scegli **Connect** per configurare l'origine dati. Rimani su questa pagina mentre viene creata la tua fonte di dati. Quando sarà pronta, verrai indirizzato alla pagina dei dettagli dell'origine dati. ## Fasi successive ### Visita OpenSearch Dashboards Dopo aver creato un'origine dati, OpenSearch Service ti fornisce un URL per i OpenSearch dashboard. È possibile utilizzarlo per configurare il controllo degli accessi, definire tabelle, configurare dashboard basati sui tipi di log per i tipi di log più diffusi e interrogare i dati utilizzando SQL o PPL. Per ulteriori informazioni, consulta [Configurazione e interrogazione di un'origine dati CloudWatch Logs nei dashboard OpenSearch](direct-query-cloudwatch-logs-configure.md). ## Altre risorse ### Autorizzazioni richieste per i ruoli IAM creati manualmente Quando crei un'origine dati, scegli un ruolo IAM per gestire l'accesso ai tuoi dati. Sono disponibili due opzioni: 1. Crea automaticamente un nuovo ruolo IAM 1. Utilizza un ruolo IAM esistente che hai creato manualmente Se utilizzi un ruolo creato manualmente, devi assegnare le autorizzazioni corrette al ruolo. Le autorizzazioni devono consentire l'accesso alla fonte di dati specifica e consentire a OpenSearch Service di assumere il ruolo. Ciò è necessario affinché il OpenSearch Servizio possa accedere e interagire in modo sicuro con i dati dell'utente. La seguente politica di esempio illustra le autorizzazioni con privilegi minimi necessarie per creare e gestire un'origine dati. Se disponi di autorizzazioni più ampie, ad esempio `logs:*` o la policy, queste autorizzazioni comprendono le autorizzazioni con il `AdminstratorAccess` privilegio minimo della politica di esempio. Nella seguente politica di esempio, sostituiscila con le tue informazioni. *placeholder text * ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AmazonOpenSearchDirectQueryAllLogsAccess", "Effect": "Allow", "Action": [ "logs:DescribeLogGroups", "logs:StartQuery", "logs:GetLogGroupFields" ], "Condition": { "StringEquals": { "aws:ResourceAccount": "111122223333" } }, "Resource": [ "arn:aws:logs:us-east-1:111122223333:log-group:*" ] } ] } ``` ------ Il ruolo deve inoltre avere la seguente politica di fiducia, che specifica l'ID di destinazione. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "TrustPolicyForAmazonOpenSearchDirectQueryService", "Effect": "Allow", "Principal": { "Service": "directquery.opensearchservice.amazonaws.com" }, "Action": "sts:AssumeRole", "Condition": { "ArnLike": { "aws:SourceArn": "arn:aws:opensearch:us-east-1:111122223333:datasource/rolename" } } } ] } ``` ------ Per istruzioni sulla creazione del ruolo, consulta [Creazione di un ruolo utilizzando policy di attendibilità personalizzate](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html). Per impostazione predefinita, il ruolo ha accesso solo agli indici delle origini dei dati delle query dirette. Sebbene sia possibile configurare il ruolo per limitare o concedere l'accesso all'origine dati, si consiglia di non modificare l'accesso di questo ruolo. **Se elimini l'origine dati, questo ruolo verrà eliminato**. Ciò rimuoverà l'accesso per tutti gli altri utenti se sono mappati al ruolo. ### Esempio di politica di accesso per una fonte di dati con interrogazione diretta Le politiche di accesso per le fonti di dati con query dirette seguono la sintassi delle policy IAM. Il documento di policy deve essere in formato JSON valido. La seguente politica di esempio concede un Account AWS accesso specifico all'origine dei dati delle query dirette. Nella seguente politica di esempio, sostituisci la *placeholder text* con le tue informazioni. ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::account-id:root" }, "Action": [ "opensearch:StartDirectQuery", "opensearch:GetDirectQuery", "opensearch:CancelDirectQuery", "opensearch:GetDirectQueryResult" ], "Resource": "arn:aws:opensearch:region:account-id:datasource/data-source-name" } ] } ``` Se non configuri una politica di accesso, solo il proprietario dell'origine dati ha accesso all'origine dati. # Configurazione e interrogazione di un'origine dati CloudWatch Logs nei dashboard OpenSearch Ora che hai creato la tua fonte di dati, puoi iniziare a utilizzarla Dashboards. OpenSearch Questa sezione illustra vari casi d'uso con la tua fonte di dati nelle OpenSearch dashboard. ## Interroga i gruppi di log dalla pagina Discover Nella pagina OpenSearch Discover, puoi utilizzare la nuova fonte di dati di Direct Query configurata per interrogare i gruppi di log di CloudWatch Logs. Per fare ciò, scegli **Esplora i registri**, quindi usa la barra di ricerca per creare la tua query usando SQL o PPL. Puoi filtrare, ordinare e visualizzare i dati restituiti dai tuoi gruppi di log. Per comprendere quali istruzioni, comandi e limitazioni sono supportati per l'integrazione con CloudWatch Logs, consulta. [Comandi SQL e PPL supportati](direct-query-supported-commands.md) ## Crea una visualizzazione del dashboard per la tua fonte di dati Quando utilizzi OpenSearch Service, puoi analizzare rapidamente i tipi di AWS log più diffusi utilizzando modelli di dashboard predefiniti. Per CloudWatch i registri sono disponibili modelli per i log VPC CloudTrail e Network Firewall. AWS WAF Questi modelli consentono di creare rapidamente una dashboard personalizzata in base ai dati specifici. Includono dashboard personalizzati per quel tipo di registro specifico. Ciò consente di iniziare rapidamente ad analizzare queste fonti di AWS log popolari, senza dover creare tutto da zero. **Nota** Le dashboard utilizzano viste indicizzate, che acquisiscono dati dai CloudWatch log utilizzando unità di OpenSearch calcolo a query diretta (OCUs), nonché l'indicizzazione, la ricerca e l'archiviazione delle raccolte senza server. OCUs OCUs Segui questi passaggi per creare una dashboard utilizzando uno di questi modelli predefiniti, in modo da poter iniziare subito a esplorare e analizzare i tuoi dati. **Per creare una visualizzazione del pannello di controllo** 1. Accedi alla console di Amazon OpenSearch Service all'indirizzo[https://console.aws.amazon.com/aos/](https://console.aws.amazon.com/aos/). 1. Dal riquadro di navigazione a sinistra, scegli **Gestione centrale**, quindi **Origini dati connesse**. 1. Seleziona l'origine dati per aprire la pagina dei dettagli. 1. Seleziona **Crea pannello di controllo**. 1. Scegli il tipo di dashboard che desideri creare. 1. Inserisci un nome per la dashboard. 1. Inserisci una descrizione opzionale per la dashboard. 1. Seleziona uno o più gruppi di log da visualizzare nella dashboard. 1. Scegli la frequenza con cui aggiornare i dati nella dashboard. 1. Scegli l' OpenSearch area di lavoro che desideri utilizzare. 1. Per creare un nuovo spazio di lavoro, seleziona **Crea nuovo spazio di lavoro** e inserisci un nome. 1. Per utilizzare un'area di lavoro esistente, seleziona **Seleziona** un'area di lavoro esistente. 1. Seleziona **Crea pannello di controllo**. ## Interrogazione dei CloudWatch dati dei log in Discover OpenSearch Per interrogare i dati, seleziona la fonte dei dati dal menu a discesa. Se utilizzi CloudWatch Logs, accedi a Discover dall'area di lavoro Essentials e inizia a interrogare i dati utilizzando OpenSearch SQL o Piped Processing Language (PPL). Per un elenco dei comandi supportati, consulta. [Comandi SQL e PPL supportati](direct-query-supported-commands.md) **Nota** Se hai creato una vista materializzata, puoi usare DQL per interrogare i tuoi dati, purché li abbia indicizzati all'interno. ### Risoluzione dei problemi Potrebbero verificarsi casi in cui i risultati non vengono restituiti come previsto. In caso di problemi, assicurati di seguire il[Raccomandazioni](direct-query-cloudwatch-logs-overview.md#direct-query-cloudwatch-logs-recommendations). ## Prezzi Amazon OpenSearch Service offre prezzi OpenSearch Compute Unit (OCU) per le query dirette di CloudWatch Logs. Quando esegui query dirette, ti vengono addebitati addebiti orari, indicati nella fattura come OCUs DirectQuery tipo di utilizzo dell'OCU. Inoltre, ti verranno addebitati costi separati da Amazon CloudWatch Logs. Le query dirette sono di due tipi: interattive e con visualizzazione indicizzata. + *Le query interattive* vengono utilizzate per compilare il selettore di dati ed eseguire analisi sui dati nei registri. CloudWatch OpenSearch Il servizio gestisce ogni query con un job separato pre-riscaldato, senza mantenere una sessione prolungata. + Le *query di visualizzazione indicizzata* utilizzano il calcolo per mantenere le viste indicizzate nel Servizio. OpenSearch Queste query in genere richiedono più tempo perché inseriscono una quantità variabile di dati in un indice denominato. Per le origini dati CloudWatch connesse a Logs, i dati indicizzati vengono archiviati in una raccolta OpenSearch Serverless in cui vengono addebitati i dati indicizzati (IndexingOCU), i dati ricercati (SearchOCU) e i dati archiviati in GB. Per ulteriori informazioni, consulta le sezioni Direct Query e Serverless all'interno [dei prezzi OpenSearch di Amazon Service](https://aws.amazon.com/opensearch-service/pricing/). ## Limitazioni Le seguenti limitazioni si applicano alle query dirette nei CloudWatch log: + L'integrazione diretta delle query con CloudWatch Logs è disponibile solo nelle raccolte di OpenSearch servizi e nell' OpenSearch interfaccia utente. + OpenSearch Le raccolte serverless hanno limiti di payload in rete di 100 MiB. + CloudWatch Logs supporta VPC Flow CloudTrail AWS WAF e integrazioni di dashboard installate dalla console. + AWS CloudFormation i modelli non sono ancora supportati. + OpenSearch Le istruzioni SQL e OpenSearch PPL presentano limitazioni diverse quando si lavora con OpenSearch gli indici rispetto all'utilizzo di query dirette. Direct Query supporta comandi avanzati come JOINs sottoquery e ricerche, mentre il supporto per questi comandi sugli OpenSearch indici è limitato o inesistente. Per ulteriori informazioni, consulta [Comandi SQL e PPL supportati](direct-query-supported-commands.md). ## Raccomandazioni Quando si utilizzano interrogazioni dirette nei log, si consiglia quanto segue: CloudWatch + Quando si cercano più gruppi di log in un'unica query, utilizzare la sintassi appropriata. Per ulteriori informazioni, consulta [Funzioni di gruppo multi-log](supported-directquery-sql.md#multi-log-queries). + Quando usi i comandi SQL o PPL, racchiudi alcuni campi tra i backtick per interrogarli correttamente. I backtick sono necessari per i campi con caratteri speciali (non alfabetici e non numerici). Ad esempio, racchiudi e inserisci i contrassegni. `@message` `Operation.Export,` `Test::Field` Non è necessario racchiudere colonne con nomi puramente alfabetici nei backtick. Query di esempio con campi semplici: ``` SELECT SessionToken, Operation, StartTime FROM `LogGroup-A` LIMIT 1000; ``` Query simile con backtick aggiunti: ``` SELECT `@SessionToken`, `@Operation`, `@StartTime` FROM `LogGroup-A` LIMIT 1000; ``` + Usa dei limiti per le tue query per assicurarti di non recuperare troppi dati. + Le query contenenti nomi di campo identici ma che differiscono solo nel caso in cui (ad esempio `field1` e`FIELD1`) non siano supportate. Ad esempio, le seguenti query non sono supportate: ``` Select AWSAccountId, AwsAccountId from LogGroup Select a.@LogStream, b.@logStream from Table A INNER Join Table B ona.id = b.id ``` Tuttavia, la seguente query è supportata perché il nome del campo (@logStream) è identico in entrambi i gruppi di log: ``` Select a.@logStream, b.@logStream from Table A INNER Join Table B on a.id = b.id ``` + Le funzioni e le espressioni devono operare sui nomi dei campi e far parte di un'`SELECT`istruzione con un gruppo di log specificato nella `FROM` clausola. Ad esempio, questa query non è supportata: ``` SELECT cos(10) FROM LogGroup ``` Questa interrogazione è supportata: ``` SELECT cos(field1) FROM LogGroup ``` ## Quote **Nota** Se stai cercando di eseguire query dirette utilizzando CloudWatch Logs Insights, assicurati di fare riferimento a. [Informazioni aggiuntive per gli utenti di CloudWatch Logs Insights che utilizzano SQL OpenSearch](supported-directquery-sql.md#supported-sql-for-multi-log-queries) | Description | Valore | Limite flessibile? | Note | | --- | --- | --- | --- | | Limite TPS a livello di account per le query dirette APIs | 3 TPS | Sì | | | Numero massimo di fonti di dati | 20 | Sì | Il limite è per Account AWS. | | Numero massimo di indici o viste materializzate con aggiornamento automatico | 30 | Sì | Il limite è per fonte di dati. | | Numero massimo di interrogazioni simultanee | 30 | Sì | Il limite è per origine dati e si applica alle query in sospeso o in esecuzione. Include query interattive (ad esempio comandi di recupero dati come`SELECT`) e query di indice (ad esempio, operazioni come/). `CREATE` `ALTER` | | Numero massimo di OCU simultanee per query | 512 | Sì | OpenSearch Unità di calcolo (OCU). Limite basato su 15 executor e 1 driver, ciascuno con 16 vCPU e 32 GB di memoria. Rappresenta la potenza di elaborazione simultanea. | | Tempo massimo di esecuzione delle query in minuti | 60 | No | Il limite si applica alle query OpenSearch PPL/SQL in Logs Insights. CloudWatch | | Periodo di eliminazione delle query obsolete IDs | 90 giorni | Sì | Questo è il periodo di tempo dopo il quale il OpenSearch Servizio elimina i metadati delle query dalle voci precedenti. Ad esempio, una chiamata GetDirectQuery o un GetDirectQueryResult errore per le query che risalgono a più di 90 giorni. | ## Supportato Regioni AWS Quanto segue Regioni AWS è supportato per le interrogazioni dirette nei CloudWatch registri: + Asia Pacifico (Mumbai) + Asia Pacifico (Hong Kong) + Asia Pacifico (Osaka) + Asia Pacifico (Seoul) + Asia Pacifico (Singapore) + Asia Pacifico (Sydney) + Asia Pacifico (Tokyo) + Canada (Centrale) + Europa (Francoforte) + Europa (Irlanda) + Europa (Stoccolma) + Europa (Milano) + Europa (Spagna) + Stati Uniti orientali (Virginia settentrionale) + Stati Uniti orientali (Ohio) + Stati Uniti occidentali (Oregon) + Stati Uniti occidentali (California settentrionale) + Europa (Parigi) + Europa (Londra) + Sud America (San Paolo) # Interrogazione diretta dei dati di Amazon Security Lake nel servizio OpenSearch Questa sezione ti guiderà attraverso il processo di creazione e configurazione di un'integrazione di fonti di dati in Amazon OpenSearch Service, consentendoti di interrogare e analizzare in modo efficiente i tuoi dati archiviati in Security Lake. Nelle pagine seguenti, imparerai come configurare un'origine dati con query diretta di Security Lake, esplorare i prerequisiti necessari e seguire le step-by-step procedure utilizzando il. Console di gestione AWS **Topics** + [Creazione di un'integrazione di origini dati Amazon Security Lake in OpenSearch Service](direct-query-security-lake-creating.md) + [Configurazione e interrogazione di un'origine dati Security Lake nelle dashboard OpenSearch](direct-query-security-lake-configure.md) + [Prezzi](#direct-query-security-lake-pricing) + [Limitazioni](#direct-query-security-lake-limitations) + [Raccomandazioni](#direct-query-security-lake-recommendations) + [Quote](#direct-query-security-lake-quotas) + [Supportato Regioni AWS](#direct-query-security-lake-regions) # Creazione di un'integrazione di origini dati Amazon Security Lake in OpenSearch Service Puoi usare Amazon OpenSearch Serverless per interrogare direttamente i dati di sicurezza in Amazon Security Lake. Per fare ciò, crei una fonte di dati che ti consenta di utilizzare funzionalità OpenSearch zero-ETL sui dati di Security Lake. Quando si crea un'origine dati, è possibile cercare, ottenere informazioni e analizzare direttamente i dati archiviati in Security Lake. È possibile accelerare le prestazioni delle query e utilizzare OpenSearch analisi avanzate su determinati set di dati di Security Lake utilizzando l'indicizzazione su richiesta. **Topics** + [Prerequisiti](#direct-query-s3security-lake-prereq) + [Procedura](#direct-query-security-lake-create) + [Fasi successive](#direct-query-security-lake-next-steps) + [Altre risorse](#direct-query-security-lake-additional-resources) ## Prerequisiti Prima di iniziare, assicurati di aver letto la seguente documentazione: + [Limitazioni](direct-query-security-lake-overview.md#direct-query-security-lake-limitations) + [Raccomandazioni](direct-query-security-lake-overview.md#direct-query-security-lake-recommendations) + [Quote](direct-query-security-lake-overview.md#direct-query-security-lake-quotas) Prima di creare un'origine dati, esegui le seguenti azioni in Security Lake: + **Abilita Security Lake**. Configura Security Lake per raccogliere i log sulla Regione AWS stessa OpenSearch risorsa. Per istruzioni, consulta la sezione [Guida introduttiva ad Amazon Security Lake](https://docs.aws.amazon.com/security-lake/latest/userguide/getting-started.html) nella guida per l'utente di Amazon Security Lake. + **Configura le autorizzazioni di Security Lake**. Assicurati di aver accettato le autorizzazioni relative ai ruoli collegati al servizio per la gestione delle risorse e che la console non mostri alcun problema nella pagina **Problemi**. Per ulteriori informazioni, consulta il [ruolo collegato ai servizi per Security Lake nella guida](https://docs.aws.amazon.com/security-lake/latest/userguide/using-service-linked-roles.html) per l'utente di Amazon Security Lake. + **Condividi le fonti di dati di Security Lake**. Quando accedi OpenSearch allo stesso account di Security Lake, assicurati che non ci sia alcun messaggio per registrare i tuoi bucket Security Lake con Lake Formation nella console di Security Lake. Per OpenSearch l'accesso su più account, configura un abbonato alle query di Lake Formation nella console Security Lake. Usa l'account associato alla tua OpenSearch risorsa come abbonato. Per ulteriori informazioni, consulta [Gestione degli abbonati in Security Lake](https://docs.aws.amazon.com/security-lake/latest/userguide/create-query-subscriber-procedures.html) nella guida per l'utente di Amazon Security Lake. Inoltre, devi avere a disposizione anche le seguenti risorse: Account AWS + **(Facoltativo) Un ruolo IAM creato manualmente.** Puoi utilizzare questo ruolo per gestire l'accesso alla tua fonte di dati. In alternativa, puoi fare in modo che OpenSearch Service crei automaticamente un ruolo per te con le autorizzazioni richieste. Se scegli di utilizzare un ruolo IAM creato manualmente, segui le indicazioni riportate in[Autorizzazioni richieste per i ruoli IAM creati manualmente](#direct-query-security-lake-additional-resources-required-permissions). ## Procedura È possibile configurare un'origine dati per connettersi a un database di Security Lake dall'interno di Console di gestione AWS. ### Per configurare una fonte di dati utilizzando il Console di gestione AWS 1. Accedi alla console di Amazon OpenSearch Service all'indirizzo[https://console.aws.amazon.com/aos/](https://console.aws.amazon.com/aos/). 1. Nel riquadro di navigazione a sinistra, vai a **Gestione centrale** e scegli **Origini dati connesse**. 1. Scegli **Connetti**. 1. Scegli **Security Lake** come tipo di origine dati. 1. Scegli **Next (Successivo)**. 1. In **Dettagli della connessione dati**, inserisci un nome e una descrizione opzionale. 1. In **Impostazioni di accesso tramite autorizzazione IAM**, scegli come gestire l'accesso alla tua fonte di dati. 1. Se desideri creare automaticamente un ruolo per questa fonte di dati, segui questi passaggi: 1. Seleziona **Crea un nuovo ruolo**. 1. Inserire un nome per il ruolo IAM. 1. Seleziona una o più AWS Glue tabelle per definire quali dati possono essere interrogati. 1. Se desideri utilizzare un ruolo esistente che gestisci tu stesso, segui questi passaggi: 1. Seleziona **Utilizza un ruolo esistente**. 1. Seleziona un ruolo esistente dal menu a discesa. **Nota** Quando utilizzi il tuo ruolo, devi assicurarti che disponga di tutte le autorizzazioni necessarie allegando le policy richieste dalla console IAM. Per ulteriori informazioni, consulta [Autorizzazioni richieste per i ruoli IAM creati manualmente](#direct-query-security-lake-additional-resources-required-permissions). 1. (Facoltativo) In **Tag**, aggiungi tag alla tua fonte di dati. 1. Scegli **Next (Successivo)**. 1. In **Configurazione OpenSearch**, scegli come eseguire la configurazione OpenSearch. 1. Controlla i nomi delle risorse predefiniti e le impostazioni di conservazione dei dati. Quando utilizzi le impostazioni predefinite, vengono create automaticamente una nuova OpenSearch applicazione e un'area di lavoro Essentials senza costi aggiuntivi. OpenSearch consente di analizzare più fonti di dati. Include aree di lavoro, che offrono esperienze personalizzate per i casi d'uso più diffusi. Le aree di lavoro supportano il controllo degli accessi, consentendoti di creare spazi privati per i tuoi casi d'uso e condividerli solo con i tuoi collaboratori. 1. Usa impostazioni personalizzate: 1. Scegliere **Customize (Personalizza)**. 1. Modifica il nome della raccolta e le impostazioni di conservazione dei dati secondo necessità. 1. Seleziona l' OpenSearch applicazione e l'area di lavoro che desideri utilizzare. 1. Scegli **Next (Successivo)**. 1. Rivedi le tue scelte e scegli **Modifica** se devi apportare modifiche. 1. Scegli **Connect** per configurare l'origine dati. Rimani su questa pagina mentre viene creata la tua fonte di dati. Quando sarà pronta, verrai indirizzato alla pagina dei dettagli dell'origine dati. ## Fasi successive ### Visita OpenSearch Dashboards e crea una dashboard Dopo aver creato un'origine dati, OpenSearch Service ti fornisce un URL per i OpenSearch dashboard. Lo usi per interrogare i tuoi dati utilizzando SQL o PPL. L'integrazione con Security Lake include modelli di query preconfezionati per SQL e PPL che consentono di iniziare ad analizzare i log. Per ulteriori informazioni, consulta [Configurazione e interrogazione di un'origine dati Security Lake nelle dashboard OpenSearch](direct-query-security-lake-configure.md). ## Altre risorse ### Autorizzazioni richieste per i ruoli IAM creati manualmente Quando crei un'origine dati, scegli un ruolo IAM per gestire l'accesso ai tuoi dati. Sono disponibili due opzioni: 1. Crea automaticamente un nuovo ruolo IAM 1. Utilizza un ruolo IAM esistente che hai creato manualmente Se utilizzi un ruolo creato manualmente, devi assegnare le autorizzazioni corrette al ruolo. Le autorizzazioni devono consentire l'accesso alla fonte di dati specifica e consentire al OpenSearch Servizio di assumere il ruolo in modo che il OpenSearch Servizio possa accedere e interagire con i dati in modo sicuro. Inoltre, concedi LakeFormation le autorizzazioni al ruolo per tutti i database e le tabelle su cui desideri eseguire la query. Concedi `DESCRIBE` le autorizzazioni per il ruolo sui SecurityLake database a cui desideri eseguire la query dalla connessione di interrogazione diretta. Concedi almeno `SELECT and DESCRIBE` le autorizzazioni al ruolo di origine dati per le tabelle all'interno del database. La seguente politica di esempio illustra le autorizzazioni con privilegi minimi necessarie per creare e gestire un'origine dati. Se disponi di autorizzazioni più ampie, come la policy, queste autorizzazioni comprendono le autorizzazioni con il `AdminstratorAccess` privilegio minimo della policy di esempio. Nella seguente politica di esempio, sostituiscila con le tue informazioni. *placeholder text * ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AmazonOpenSearchDirectQueryServerlessAccess", "Effect": "Allow", "Action": [ "aoss:APIAccessAll", "aoss:DashboardsAccessAll" ], "Resource": "arn:aws:aoss:us-east-1:111122223333:collection/collectionname/*" }, { "Sid": "AmazonOpenSearchDirectQueryGlueAccess", "Effect": "Allow", "Action": [ "glue:GetDatabase", "glue:GetDatabases", "glue:GetPartition", "glue:GetPartitions", "glue:GetTable", "glue:GetTableVersions", "glue:GetTables", "glue:SearchTables", "glue:BatchGetPartition" ], "Resource": [ "arn:aws:glue:us-east-1:111122223333:table/databasename/*", "arn:aws:glue:us-east-1:111122223333:database/databasename", "arn:aws:glue:us-east-1:111122223333:catalog", "arn:aws:glue:us-east-1:111122223333:database/default" ] }, { "Sid": "AmazonOpenSearchDirectQueryLakeFormationAccess", "Effect": "Allow", "Action": [ "lakeformation:GetDataAccess" ], "Resource": [ "*" ] } ] } ``` ------ Il ruolo deve inoltre avere la seguente politica di fiducia, che specifica l'ID di destinazione. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "directquery.opensearchservice.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ Per istruzioni sulla creazione del ruolo, consulta [Creazione di un ruolo utilizzando policy di attendibilità personalizzate](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html). Per impostazione predefinita, il ruolo ha accesso solo agli indici delle origini dei dati delle query dirette. Sebbene sia possibile configurare il ruolo per limitare o concedere l'accesso all'origine dati, si consiglia di non modificare l'accesso di questo ruolo. **Se elimini l'origine dati, questo ruolo verrà eliminato**. Ciò rimuoverà l'accesso per tutti gli altri utenti se sono mappati al ruolo. ### Interrogazione dei dati di Security Lake crittografati con una chiave gestita dal cliente Se il bucket Security Lake associato alla connessione dati è crittografato utilizzando la crittografia lato server con gestione dal cliente AWS KMS key, è necessario aggiungere il ruolo di LakeFormation servizio alla policy chiave. Ciò consente al servizio di accedere e leggere i dati per le tue domande. Nel seguente esempio di politica, sostituisci le tue informazioni *placeholder text * con le tue. ``` { "Sid": "Allow LakeFormation to access the key", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::account:role/aws-service-role/lakeformation.amazonaws.com/AWSServiceRoleForLakeFormationDataAccess" }, "Action": [ "kms:Encrypt", "kms:Decrypt", "kms:ReEncrypt*", "kms:GenerateDataKey*", "kms:DescribeKey" ], "Resource": "*" } ``` # Configurazione e interrogazione di un'origine dati Security Lake nelle dashboard OpenSearch Ora che hai creato la tua fonte di dati, puoi configurarla nelle dashboard. OpenSearch Questa sezione illustra vari casi d'uso con la tua fonte di dati nelle OpenSearch dashboard prima di interrogare i dati. Per iniziare, devi accedere alla tua fonte di dati in OpenSearch Dashboards. **Nel menu a sinistra, in **Gestione**, scegli Origini dati.** Quindi, seleziona il nome dell'origine dati che hai creato in precedenza nella console di OpenSearch servizio. ## Interroga le tabelle di Security Lake da Discover Se hai creato tabelle in base ai log di Security Lake, ora puoi interrogare tali tabelle direttamente da OpenSearch Discover. Ciò consente di accedere e analizzare senza problemi i dati archiviati in Security Lake, direttamente dalla familiare interfaccia Discover. Interrogando Security Lake direttamente da Discover, puoi evitare la necessità di estrarre, trasformare e caricare manualmente i dati in un indice di ricerca separato. Per iniziare rapidamente ad analizzare i log, Discover include una serie di query salvate in PPL e SQL. Inizia selezionando l'origine dati che hai configurato. Seleziona il database e la tabella associati su cui desideri interrogare, quindi usa la barra di ricerca per scrivere query sulle tue tabelle. Per capire quali istruzioni, comandi e limitazioni sono supportati per l'integrazione di Security Lake, consulta[Comandi SQL e PPL supportati](direct-query-supported-commands.md). **Per sfruttare le query predefinite disponibili per Security Lake, vai a...** **in alto a destra di Discover, scegli **Apri query**, quindi scegli Modelli.** Sono disponibili molte query predefinite per le fonti di registro supportate in Security Lake. Cerca i modelli che corrispondono al tuo caso d'uso, copia la query da utilizzare nella barra di ricerca e sostituisci i campi basati su modelli (come Regione e azione) con le tue informazioni. ## Accelera i dati da Discover Per migliorare le prestazioni e consentire query e analisi successive più rapide OpenSearch, puoi inserire i risultati della query da Discover in una vista OpenSearch indicizzata. **Per creare una vista indicizzata** 1. Da Discover, scegli **Crea vista indicizzata**. 1. Nell'editor di query, inserisci la query desiderata. Puoi creare una nuova interrogazione qui o usarne una esistente dalle tue ricerche precedenti. 1. Specificate un nome per la nuova vista indicizzata. Scegliete un nome descrittivo che vi aiuti a identificare la vista in un secondo momento. 1. Configura le impostazioni di conservazione dei dati per la visualizzazione indicizzata. È possibile specificare per quanto tempo i dati devono essere conservati nell'indice, in modo da bilanciare le prestazioni con i costi di archiviazione. 1. Crea la vista indicizzata. Dopo la creazione, la vista indicizzata sarà disponibile per interrogazioni e analisi più rapide. Se hai già creato viste indicizzate, puoi accedervi da Discover. **Per utilizzare una visualizzazione indice esistente** 1. Da Discover, scegli **Seleziona visualizzazione indicizzata per visualizzare** un elenco delle viste indicizzate esistenti per Security Lake. 1. Scegli la vista indicizzata che desideri utilizzare. Ciò applicherà la visualizzazione alla query corrente, velocizzando potenzialmente in modo significativo il recupero e l'analisi dei dati. ## Crea una visualizzazione del dashboard per la tua fonte di dati Quando utilizzi OpenSearch Service, puoi analizzare i tipi di AWS log più diffusi utilizzando modelli di dashboard predefiniti. Per Security Lake sono disponibili modelli per i log VPC e WAF. CloudTrail Questi modelli consentono di creare una dashboard personalizzata in base ai dati specifici. Includono query e dashboard predefiniti personalizzati per quel tipo di registro specifico. Ciò consente di iniziare rapidamente ad analizzare queste fonti di AWS log popolari, senza dover creare tutto da zero. **Nota** Le dashboard utilizzano viste indicizzate, che acquisiscono dati da Security Lake e contribuiscono al calcolo diretto delle interrogazioni e della raccolta. Segui questi passaggi per creare una dashboard utilizzando uno di questi modelli predefiniti, in modo da poter iniziare subito a esplorare e analizzare i tuoi dati. **Per creare una visualizzazione del pannello di controllo** 1. Accedi alla console di Amazon OpenSearch Service all'indirizzo[https://console.aws.amazon.com/aos/](https://console.aws.amazon.com/aos/). 1. Dal riquadro di navigazione a sinistra, scegli **Gestione centrale**, quindi **Origini dati connesse**. 1. Seleziona l'origine dati per aprire la pagina dei dettagli. 1. Seleziona **Crea pannello di controllo**. 1. Scegli il tipo di dashboard che desideri creare. 1. Inserisci un nome per la dashboard. 1. Inserisci una descrizione opzionale per la dashboard. 1. Seleziona una o più tabelle AWS Glue da visualizzare sulla dashboard. 1. Scegli la frequenza con cui aggiornare i dati nella dashboard. 1. Scegli l' OpenSearch area di lavoro che desideri utilizzare. 1. Per creare un nuovo spazio di lavoro, seleziona **Crea nuovo** spazio di lavoro. 1. Per utilizzare un'area di lavoro esistente, seleziona **Seleziona** un'area di lavoro esistente. 1. Inserisci un nome per il tuo spazio di lavoro. 1. Seleziona **Crea pannello di controllo**. ## Risoluzione dei problemi In alcuni casi i risultati non vengono restituiti come previsto. In caso di problemi, assicurati di seguire il[Raccomandazioni](direct-query-security-lake-overview.md#direct-query-security-lake-recommendations). ## Prezzi Amazon OpenSearch Service offre prezzi OpenSearch Compute Unit (OCU) per le query dirette di Security Lake. Quando esegui le query dirette, ti vengono addebitati addebiti orari, indicati nella fattura OCUs come tipo di utilizzo dell' DirectQuery OCU. Ti verranno inoltre addebitati addebiti separati da Amazon Security Lake. Le interrogazioni dirette sono di due tipi: interattive e con visualizzazione indicizzata. + *Le query interattive* vengono utilizzate per compilare il selettore di dati ed eseguire analisi sui dati in Security Lake. OpenSearch Il servizio gestisce ogni query con un job separato pre-riscaldato, senza mantenere una sessione prolungata. + Le *query di visualizzazione indicizzata* utilizzano il calcolo per mantenere le viste indicizzate nel Servizio. OpenSearch Queste query in genere richiedono più tempo perché inseriscono una quantità variabile di dati in un indice denominato. Per le sorgenti dati connesse a Security Lake, i dati indicizzati vengono archiviati in una raccolta OpenSearch Serverless in cui vengono addebitati i dati indicizzati (IndexingOCU), i dati ricercati (SearchOCU) e i dati archiviati in GB. Per ulteriori informazioni, consulta le sezioni Direct Query e Serverless all'interno [dei prezzi OpenSearch di Amazon Service](https://aws.amazon.com/opensearch-service/pricing/). ## Limitazioni Le seguenti limitazioni si applicano alle query dirette in Security Lake: + L'integrazione diretta delle query con Security Lake è disponibile solo nelle raccolte OpenSearch di servizi e nell'interfaccia OpenSearch utente. + OpenSearch Le raccolte serverless hanno limiti di payload in rete di 100 MiB. + La gestione delle tabelle per Security Lake viene eseguita in Lake Formation. + Security Lake supporta solo le viste materializzate come viste indicizzate. Gli indici di copertura non sono supportati. + AWS CloudFormation i modelli non sono ancora supportati. + OpenSearch Le istruzioni SQL e OpenSearch PPL presentano limitazioni diverse quando si lavora con OpenSearch gli indici rispetto all'utilizzo di query dirette. Direct Query supporta comandi avanzati come JOINs sottoquery e ricerche, mentre il supporto per questi comandi sugli OpenSearch indici è limitato o inesistente. Per ulteriori informazioni, consulta [Comandi SQL e PPL supportati](direct-query-supported-commands.md). ## Raccomandazioni Per l'utilizzo di query dirette in Security Lake, consigliamo quanto segue: + Controlla lo stato del tuo Security Lake e assicurati che funzioni senza problemi. Per una procedura dettagliata di risoluzione dei problemi, consulta [Risoluzione dei problemi dello stato del data lake](https://docs.aws.amazon.com/security-lake/latest/userguide/securitylake-data-lake-troubleshoot.html) nella Guida per l'utente di Amazon Security Lake. + Verifica l'accesso alla tua query: + Se stai interrogando Security Lake da un account diverso dall'account amministratore delegato di Security Lake, [configura un abbonato con accesso alle query in](https://docs.aws.amazon.com/security-lake/latest/userguide/subscriber-query-access.html) Security Lake. + Se stai interrogando Security Lake dallo stesso account, controlla la presenza di messaggi in Security Lake sulla registrazione dei bucket S3 gestiti con. LakeFormation + Esplora i modelli di query e le dashboard predefinite per iniziare subito l'analisi. + Acquisisci familiarità con Open Cybersecurity Schema Framework (OCSF) e Security Lake: + [Esamina gli esempi di mappatura degli schemi per le fonti nel repository OCSF AWS GitHub ](https://github.com/ocsf/examples/tree/main/mappings/markdown/AWS/v1.1.0/CloudTrail) + Scopri come interrogare Security Lake in modo efficace visitando [Security Lake queries for AWS source version](https://docs.aws.amazon.com/security-lake/latest/userguide/subscriber-query-examples2.html) 2 (OCSF 1.1.0) + Migliora le prestazioni delle query utilizzando le partizioni:,, e `accountid` `region` `time_dt` + Prendi confidenza con la sintassi SQL, supportata da Security Lake per le interrogazioni. Per ulteriori informazioni, consulta [Comandi e funzioni OpenSearch SQL supportati](supported-directquery-sql.md). + Usa dei limiti per le tue query per assicurarti di non recuperare troppi dati. ## Quote | Description | Valore | Limite flessibile? | Note | | --- | --- | --- | --- | | Limite TPS a livello di account per le query dirette APIs | 3 TPS | Sì | | | Numero massimo di fonti di dati | 20 | Sì | Il limite è per Account AWS. | | Numero massimo di indici o viste materializzate con aggiornamento automatico | 30 | Sì | Il limite si applica per fonte di dati. Include solo indici e viste materializzate (MVs) con aggiornamento automatico impostato su true. | | Numero massimo di interrogazioni simultanee | 30 | Sì | Il limite si applica alle query in sospeso o in esecuzione. Include query interattive (ad esempio comandi per il recupero dei dati come`SELECT`) e query sull'indice (ad esempio, operazioni come//). `CREATE` `ALTER` `DROP` | | Numero massimo di OCU simultanee per query | 512 | Sì | OpenSearch Unità di calcolo (OCU). Limite basato su 15 executor e 1 driver, ciascuno con 16 vCPU e 32 GB di memoria. Rappresenta la potenza di elaborazione simultanea. | | Tempo massimo di esecuzione delle query in minuti | 30 | No | Si applica solo alle query interattive (ad esempio, comandi di recupero dati come). SELECT Per le REFRESH interrogazioni, il limite è di 6 ore. | | Periodo di eliminazione delle interrogazioni obsolete IDs | 90 giorni | Sì | Questo è il periodo di tempo dopo il quale il OpenSearch Servizio elimina i metadati delle query dalle voci precedenti. Ad esempio, una chiamata GetDirectQuery o un GetDirectQueryResult errore per le query che risalgono a più di 90 giorni. | ## Supportato Regioni AWS Le seguenti opzioni Regioni AWS sono supportate per le interrogazioni dirette in Security Lake: + Asia Pacifico (Mumbai) + Asia Pacifico (Singapore) + Asia Pacifico (Sydney) + Asia Pacifico (Tokyo) + Canada (Centrale) + Europa (Francoforte) + Europa (Irlanda) + Europa (Stoccolma) + Stati Uniti orientali (Virginia settentrionale) + Stati Uniti orientali (Ohio) + Stati Uniti occidentali (Oregon) + Europa (Parigi) + Europa (Londra) + Sud America (San Paolo) # Interrogazioni dirette in Amazon Managed Service per Prometheus Puoi utilizzare Amazon OpenSearch Service per interrogare direttamente i parametri operativi archiviati in Amazon Managed Service for Prometheus. Questa integrazione consente di analizzare e visualizzare i dati delle serie temporali di Prometheus insieme ai log e alle tracce OpenSearch all'interno dell'interfaccia utente, abilitando un'esperienza di osservabilità unificata. A differenza delle query dirette basate sullo storage (come Amazon S3 o Logs CloudWatch ), l'integrazione con Prometheus utilizza un'architettura di chiamate live. OpenSearch Service funge da cliente diretto, traduce le tue domande ed effettua chiamate API in tempo reale verso il tuo spazio di lavoro Prometheus. Poiché il OpenSearch Servizio non fornisce elaborazione temporanea per la scansione dei dati, non sono previsti costi di Compute Unit (OCU) per OpenSearch queste query. Per configurare e utilizzare questa integrazione, devi prima creare l'origine dati e quindi configurare le aree di lavoro per interrogare i dati. **Topics** + [Creazione di un'origine dati Amazon Managed Service per Prometheus](direct-query-prometheus-creating.md) + [Interrogazione delle metriche di Prometheus](direct-query-prometheus-configure.md) + [Prezzi](#direct-query-prometheus-pricing) + [Limitazioni](#direct-query-prometheus-limitations) + [Raccomandazioni](#direct-query-prometheus-recommendations) + [Quote](#direct-query-prometheus-quotas) + [Supportato Regioni AWS](#direct-query-prometheus-regions) # Creazione di un'origine dati Amazon Managed Service per Prometheus Per creare un'origine dati Amazon Managed Service for Prometheus, hai bisogno di uno spazio di lavoro attivo e di un ruolo IAM che OpenSearch conceda a Service le autorizzazioni necessarie per interrogare le tue metriche. ## Prerequisiti Prima di connettere la fonte di dati, assicurati di disporre di quanto segue: + **Prometheus workspace**: un Amazon Managed Service attivo per l'area di lavoro Prometheus. Annota il tuo ID Workspace e il suo indirizzo di residenza. Regione AWS + **Ruolo IAM**: AWS Identity and Access Management ruolo con una politica di fiducia che consente al responsabile del `directquery.opensearchservice.amazonaws.com` servizio di assumerlo. ## Connessione della fonte di dati Una volta soddisfatti i prerequisiti, puoi connettere l'origine dati utilizzando la console OpenSearch di servizio. **Per configurare un'origine dati Amazon Managed Service for Prometheus** 1. Accedi alla console di Amazon OpenSearch Service all'indirizzo[https://console.aws.amazon.com/aos/](https://console.aws.amazon.com/aos/). 1. Nel riquadro di navigazione a sinistra, vai a **Gestione centrale** e scegli **Origini dati connesse**. 1. Scegli **Connect new data source**. 1. Scegli **Amazon Managed Service for Prometheus come** tipo di origine dati. 1. Scegli **Next (Successivo)**. 1. In **Dettagli della connessione dati**, inserisci un nome e una descrizione opzionale. 1. In **Ruoli IAM**, scegli come gestire l'accesso: + Per creare automaticamente un ruolo per questa fonte di dati: 1. Seleziona **Crea un nuovo ruolo**. 1. Inserire un nome per il ruolo IAM. 1. Seleziona uno o più spazi di lavoro per definire quali dati possono essere interrogati. + Per utilizzare un ruolo esistente che gestisci tu stesso: 1. Seleziona **Utilizza un ruolo esistente**. 1. Seleziona un ruolo esistente dal menu a discesa. **Nota** Quando usi il tuo ruolo, assicurati che disponga di tutte le autorizzazioni necessarie allegando le policy richieste dalla console IAM. Per ulteriori informazioni, consulta [Autorizzazioni richieste per i ruoli IAM creati manualmente](#direct-query-prometheus-manual-role-permissions). 1. (Facoltativo) In **Politica di accesso**, configura una politica di accesso per l'origine dati. Le politiche di accesso controllano se una richiesta all'origine dati OpenSearch di Service Direct Query viene accettata o rifiutata. Se non configuri una politica di accesso, solo il proprietario dell'origine dati può accedervi. Puoi configurare la politica di accesso per abilitare l'accesso tra più account, consentendo ai responsabili di altri di accedere Account AWS alla fonte di dati. È possibile creare una politica di accesso utilizzando l'editor visivo o fornendo un documento di policy JSON. Con l'editor visivo, puoi consentire o negare l'accesso specificando un Account AWS ID principale, l'ARN dell'account, l'ARN dell'utente IAM, l'ARN del ruolo IAM, l'indirizzo IP di origine o il blocco CIDR. L'editor visivo supporta fino a 10 elementi. Per definire una policy con più di 10 elementi, usa l'editor JSON. Puoi anche scegliere **Importa policy per importare** una politica di accesso esistente da un'altra fonte di dati. 1. (Facoltativo) In **Tag**, aggiungi tag alla tua fonte di dati. 1. Scegli **Next (Successivo)**. 1. In **Configurazione OpenSearch**, scegli come configurare l' OpenSearch interfaccia utente: 1. Se nel tuo account non esiste alcuna applicazione OpenSearch UI, crea una nuova OpenSearch applicazione. Se esiste un' OpenSearch applicazione esistente, selezionala. 1. Se crei una nuova applicazione, crea un nuovo spazio di lavoro di osservabilità. Se hai selezionato un'applicazione esistente, crea un nuovo spazio di lavoro di osservabilità o selezionane uno esistente. Amazon Managed Service for Prometheus è disponibile solo nell'area di lavoro di osservabilità. 1. Scegli **Next (Successivo)**. 1. Rivedi le tue scelte e scegli **Modifica** se devi apportare modifiche. 1. Scegli **Connect** per configurare l'origine dati. Rimani su questa pagina mentre viene creata la tua fonte di dati. Quando è pronta, verrai indirizzato alla pagina dei dettagli dell'origine dati. ### Fasi successive **Visita l' OpenSearch interfaccia utente** Dopo aver creato un'origine dati, OpenSearch Service ti fornisce un URL dell'applicazione OpenSearch UI. Lo usi per configurare chi ha accesso all' OpenSearch interfaccia utente e analizzare i dati di Amazon Managed Service for Prometheus utilizzando Discover Metrics with PromQL. ### Risorse aggiuntive #### Autorizzazioni richieste per i ruoli IAM creati manualmente Quando crei un'origine dati, scegli un ruolo IAM per gestire l'accesso ai tuoi dati. Sono disponibili due opzioni: + Crea automaticamente un nuovo ruolo IAM + Utilizza un ruolo IAM esistente che hai creato manualmente Se utilizzi un ruolo creato manualmente, devi assegnare le autorizzazioni corrette al ruolo. Le autorizzazioni devono consentire l'accesso alla fonte di dati specifica e consentire a OpenSearch Service di assumere il ruolo. Ciò è necessario per consentire OpenSearch al Servizio di accedere e interagire con i dati in modo sicuro. La seguente politica di esempio illustra le autorizzazioni con privilegi minimi necessarie per creare e gestire un'origine dati. Se disponi di autorizzazioni più ampie, ad esempio `aps:*` o la policy, queste autorizzazioni comprendono le autorizzazioni con il `AdministratorAccess` privilegio minimo della politica di esempio. Nella seguente politica di esempio, sostituisci il testo con le tue informazioni. *placeholder* **Policy IAM di esempio** Assegna le seguenti autorizzazioni al tuo ruolo IAM per consentire al OpenSearch servizio di recuperare i metadati delle metriche ed eseguire le query: ``` { "Version": "2012-10-17", "Statement": [ { "Sid": "AmazonOpenSearchDirectQueryPrometheusAccess", "Effect": "Allow", "Action": [ "aps:DeleteAlertManagerSilence", "aps:GetAlertManagerSilence", "aps:GetAlertManagerStatus", "aps:GetLabels", "aps:GetMetricMetadata", "aps:GetSeries", "aps:ListAlertManagerAlertGroups", "aps:ListAlertManagerAlerts", "aps:ListAlertManagerReceivers", "aps:ListAlertManagerSilences", "aps:ListAlerts", "aps:QueryMetrics", "aps:PutAlertManagerSilences", "aps:DescribeAlertManagerDefinition", "aps:CreateRuleGroupsNamespace", "aps:DeleteRuleGroupsNamespace", "aps:ListRuleGroupsNamespaces", "aps:DescribeRuleGroupsNamespace", "aps:PutRuleGroupsNamespace" ], "Resource": "arn:aws:aps:region:account-id:workspace/workspace-id", "Condition": { "ForAnyValue:StringEquals": { "aws:CalledVia": [ "directquery.opensearchservice.amazonaws.com" ] } } }, { "Sid": "AmazonOpenSearchDirectQueryPrometheusListAccess", "Effect": "Allow", "Action": [ "aps:ListWorkspaces" ], "Resource": "*", "Condition": { "ForAnyValue:StringEquals": { "aws:CalledVia": [ "directquery.opensearchservice.amazonaws.com" ] } } } ] } ``` **Esempio di politica di fiducia** Allega la seguente politica di fiducia al tuo ruolo IAM: ``` { "Version": "2012-10-17", "Statement": [ { "Sid": "TrustPolicyForAmazonOpenSearchDirectQueryService", "Effect": "Allow", "Principal": { "Service": "directquery.opensearchservice.amazonaws.com" }, "Action": "sts:AssumeRole", "Condition": { "ArnEquals": { "aws:SourceArn": "arn:aws:opensearch:region:account-id:datasource/data-source-name" }, "StringEquals": { "aws:SourceAccount": "account-id" } } } ] } ``` # Interrogazione delle metriche di Prometheus Amazon OpenSearch Service ti consente di interrogare i tuoi dati Prometheus utilizzando PromQL (Prometheus Query Language) direttamente dall'interfaccia Observability. Quando esegui una query PromQL sull'origine dati Prometheus OpenSearch , Service passa la query direttamente all'API del tuo spazio di lavoro per l'esecuzione. ## Esecuzione di una query PromQL Per eseguire una query: 1. Apri l'applicazione OpenSearch dell'interfaccia utente e l'area di lavoro di osservabilità. 1. **Vai su **Observability** e seleziona Discover Metrics.** 1. Nel menu a discesa delle origini dati, seleziona la tua fonte dati Prometheus. 1. Inserisci la tua query PromQL nella barra delle interrogazioni. Ad esempio, per calcolare l'utilizzo medio della CPU al secondo in una finestra di 5 minuti per un pod specifico: ``` avg(rate(container_cpu_usage_seconds_total{pod="payment-service-pod"}[5m])) by (pod) ``` **Nota** Imposta il time picker su una finestra ristretta e pertinente (ad esempio, l'ultima ora) per ottimizzare le prestazioni dell'API ed evitare i timeout. ## Visualizzazione delle metriche nelle dashboard Puoi aggiungere visualizzazioni metriche basate su ProMQL ai dashboard di osservabilità esistenti per correlarle ai dati di log e traccia. 1. Vai a **Discover Metrics**, seleziona l'area di lavoro Prometheus dal menu a discesa delle fonti di dati ed esegui la query PromQL. 1. Utilizza la scheda di visualizzazione in **Discover Metrics** per creare una visualizzazione e definire il tipo di visualizzazione. 1. Salva la visualizzazione nella dashboard. **Nota** **Le visualizzazioni delle metriche possono essere aggiunte solo da Discover Metrics.** Le visualizzazioni disponibili nella scheda Visualizzazioni sono ottimizzate solo per i log. ## Prezzi Per Amazon Managed Service for Prometheus OpenSearch , Service effettua chiamate in tempo reale direttamente all'area di lavoro Prometheus per recuperare i dati. Poiché OpenSearch Service non fornisce risorse di elaborazione separate per eseguire queste query, non sono previsti costi per la Compute Unit (OCU). OpenSearch Sei responsabile solo dei costi di interrogazione standard associati ad Amazon Managed Service for Prometheus. Per ulteriori informazioni, consulta le sezioni Direct Query e Serverless all'interno [dei prezzi OpenSearch di Amazon Service](https://aws.amazon.com/opensearch-service/pricing/). ## Limitazioni Le seguenti limitazioni si applicano alle query dirette in Amazon Managed Service for Prometheus: + **Limiti relativi all'intervallo di tempo**: le query in tempo reale sono ottimizzate per i dashboard operativi. L'interrogazione di metriche altamente granulari e non sottoposte a downsampling su orizzonti temporali molto lunghi (ad esempio, su più mesi) potrebbe raggiungere i limiti di dimensione del payload o causare timeout dall'API Prometheus. + Quote **API Prometheus**: le tue domande sono soggette alle quote di servizio standard di Amazon Managed Service per Prometheus, inclusi i limiti per l'esecuzione simultanea di query Samples Processed (QSP) e l'esecuzione simultanea delle query. + **Timeout delle query: il timeout delle query a esecuzione prolungata scade dopo 30 secondi.** ## Raccomandazioni Per l'utilizzo di query dirette in Amazon Managed Service for Prometheus, consigliamo quanto segue: + **Usa regole di registrazione per lunghi intervalli di tempo**: poiché le query dirette effettuano chiamate API in tempo reale al tuo spazio di lavoro, l'esecuzione di query su dati altamente granulari per lunghi periodi (ad esempio più mesi) può comportare timeout delle API o limiti di payload. Usa le regole di registrazione di Amazon Managed Service for Prometheus per creare metriche sottocampionate per l'analisi storica. + **Applica filtri temporali ristretti**: specifica sempre un intervallo di tempo mirato nelle query OpenSearch dell'interfaccia utente per ridurre al minimo il volume di dati recuperati dinamicamente dall'API Prometheus. + **Monitora le tue quote Prometheus**: poiché queste query in tempo reale non comportano costi di Compute Unit (OCU), monitora OpenSearch invece il tuo Amazon Managed Service per l'utilizzo di Prometheus. Monitora i limiti delle query Query Samples Processed (QSP) e delle query simultanee per evitare limitazioni a livello di area di lavoro. ## Quote A differenza di altre fonti di dati di interrogazione diretta, ogni volta che avvii una query su Amazon Managed Service for Prometheus OpenSearch , Service effettua una chiamata in tempo reale ad Amazon Managed Service for Prometheus. Non viene creata alcuna sessione. Le seguenti quote sono applicabili per account e regione. Ad esempio, a un account vengono assegnate 20 fonti di dati in us-east-1 e 20 in us-east-2. | Description | Massimo | Può sovrascrivere | | --- | --- | --- | | Origini dati | 20 | Sì | | Esegui query: query istantanee e a intervallo (TPS) | 500 | Sì | | Leggi le risorse: etichette, metriche, avvisi, regole, gestore degli avvisi (TPS) | 50 | Sì | | Risorse di scrittura: create/update silence, create/update rule (TPS) | 50 | Sì | | Tempo massimo di esecuzione delle query (secondi) | 30 | No | ## Supportato Regioni AWS Quanto segue è supportato per Regioni AWS le query dirette in Amazon Managed Service for Prometheus: + Asia Pacifico (Hong Kong) + Asia Pacific (Mumbai) + Asia Pacifico (Osaka) + Asia Pacifico (Seoul) + Asia Pacifico (Singapore) + Asia Pacifico (Sydney) + Asia Pacifico (Tokyo) + Canada (Centrale) + Europa (Francoforte) + Europa (Irlanda) + Europa (Londra) + Europa (Milano) + Europa (Parigi) + Europa (Spagna) + Europa (Stoccolma) + Sud America (San Paolo) + Stati Uniti orientali (Virginia settentrionale) + Stati Uniti orientali (Ohio) + Stati Uniti occidentali (California settentrionale) + Stati Uniti occidentali (Oregon) # Gestione di un'origine dati in Amazon OpenSearch Service La gestione della fonte di dati è una parte importante per mantenere l'affidabilità, la disponibilità e le prestazioni delle fonti di dati con query dirette e delle altre AWS soluzioni. AWS fornisce i seguenti strumenti per monitorare, segnalare quando qualcosa non va e intraprendere azioni automatiche quando necessario. **Topics** + [Monitoraggio con CloudWatch fonti di dati metriche](#monitoring-cloudwatch-metrics) + [Abilitazione e disabilitazione delle fonti di dati](#direct-query-s3-enabling-disabling-data) + [Monitoraggio con budget AWS](#direct-query-s3-enabling-budget) + [Eliminazione di un'origine dati](#direct-query-s3-delete) ## Monitoraggio con CloudWatch fonti di dati metriche È possibile monitorare le interrogazioni dirette utilizzando CloudWatch. CloudWatch raccoglie dati grezzi e li elabora in metriche leggibili e quasi in tempo reale. Queste statistiche vengono conservate per un periodo di 15 mesi, per permettere l'accesso alle informazioni storiche e offrire una prospettiva migliore sulle prestazioni del servizio o dell'applicazione web. Puoi anche impostare allarmi per monitorare determinate soglie e inviare notifiche o intraprendere azioni quando tali soglie vengono raggiunte. Per ulteriori informazioni, consulta [What is Amazon CloudWatch.](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) Amazon S3 riporta i seguenti parametri: | Metrica | Description | | --- | --- | | AsyncQueryCreateAPI | Il numero totale di richieste inviate all'API per la creazione di query asincrone. **Statistiche rilevanti**: Average (Media), Maximum (Massimo), Sum (Somma) **Dimensioni:,** `ClientId` `DomainName` **Frequenza**: 60 secondi | | AsyncQueryGetApiRequestCount | Il numero totale di richieste inviate all'API per il recupero dei risultati delle query asincrone. **Statistiche rilevanti**: Average (Media), Maximum (Massimo), Sum (Somma) **Dimensioni:,** `ClientId` `DomainName` **Frequenza**: 60 secondi | | AsyncQueryCancelApiRequestCount | Il numero totale di richieste inviate all'API per l'annullamento delle query asincrone. **Statistiche rilevanti**: Average (Media), Maximum (Massimo), Sum (Somma) **Dimensioni:,** `ClientId` `DomainName` **Frequenza**: 60 secondi | | AsyncQueryGetApiFailedRequestCusErrCount | Il numero di richieste non riuscite durante il recupero dei risultati delle query asincrone a causa di errori relativi al cliente (ad esempio, ID di query non valido). **Statistiche rilevanti**: Average (Media), Maximum (Massimo), Sum (Somma) **Dimensioni:,** `ClientId` `DomainName` **Frequenza**: 60 secondi | | AsyncQueryCancelApiFailedRequestCusErrCount | Il numero di richieste non riuscite durante il recupero dei risultati delle query asincrone a causa di errori relativi al cliente (ad esempio, ID di query non valido). **Statistiche rilevanti**: Average (Media), Maximum (Massimo), Sum (Somma) **Dimensioni:,** `ClientId` `DomainName` **Frequenza**: 60 secondi | | AsyncQueryCancelApiFailedRequestSysErrCount | Il numero di richieste non riuscite durante la creazione di query asincrone a causa di errori relativi al cliente. **Statistiche rilevanti**: Average (Media), Maximum (Massimo), Sum (Somma) **Dimensioni:,** `ClientId` `DomainName` **Frequenza**: 60 secondi | | AsyncQueryGetApiFailedRequestSysErrCount | Il numero di richieste non riuscite durante il recupero dei risultati delle query asincrone a causa di errori relativi al sistema. **Statistiche rilevanti**: Average (Media), Maximum (Massimo), Sum (Somma) **Dimensioni:,** `ClientId` `DomainName` **Frequenza**: 60 secondi | CloudWatch Logs e Security Lake riportano le seguenti metriche: | Metrica | Description | | --- | --- | | DirectQueryRate | La frequenza delle richieste effettuate rispetto alle fonti di dati. **Statistiche pertinenti**: somma, massimo, minimo, media **Dimensioni**: `DataSourceName` **Frequenza**: 60 secondi | | DirectQueryLatency | La latenza osservata per l'esecuzione di query sulle fonti di dati. **Statistiche pertinenti**: media, P90, P99, somma, minima, massima **Dimensioni**: `DataSourceName` **Frequenza**: 60 secondi | | FailedDirectQueries | Il numero totale di errori di query osservati nelle query relative all'origine dati. **Statistiche pertinenti**: somma, massimo, minimo, media **Dimensioni**: `DataSourceName` **Frequenza**: 60 secondi | | DirectQueryConsumedOCU | Il numero di OCUs quelli utilizzati per eseguire le query sulle fonti di dati. **Statistiche pertinenti**: media, P90, P99, somma, minima, massima **Dimensioni**: `DataSourceName` **Frequenza**: 60 secondi | ## Abilitazione e disabilitazione delle fonti di dati **Nota** Le seguenti informazioni sono applicabili solo alle fonti di dati Amazon S3. Nei casi in cui desideri interrompere l'utilizzo diretto delle query per un'origine dati, puoi scegliere di disabilitare l'origine dati. La disabilitazione di un'origine dati terminerà l'esecuzione delle query esistenti e interromperà l'esecuzione di tutte le nuove query. L'impostazione delle accelerazioni per migliorare le prestazioni delle query, ad esempio saltare gli indici, visualizzare le viste materializzate e coprire gli indici, verrà impostata su manuale una volta disattivata l'origine dati. Una volta che un'origine dati è impostata come attiva dopo essere stata disabilitata, le query degli utenti verranno eseguite come previsto. Le accelerazioni precedentemente configurate e impostate come manuali dovranno essere configurate manualmente per essere nuovamente eseguite secondo una pianificazione. ## Monitoraggio con budget AWS Amazon OpenSearch Service sta inserendo i dati sull'utilizzo dell'OCU a livello di account nel Cost Explorer di Billing and Cost Management. Puoi tenere conto dell'utilizzo dell'OCU a livello di account e impostare soglie e avvisi quando le soglie vengono superate. Il formato del tipo di utilizzo su cui filtrare in Cost Explorer è simile a RegionCode: DirectQuery OCU (OCU-Hours). Se desideri ricevere una notifica quando l'utilizzo di DirectQuery OCU (OCU-Hours) raggiunge la tua soglia, puoi creare un account AWS Budgets e configurare un avviso in base alla soglia impostata. Facoltativamente, per Amazon S3, puoi impostare un argomento Amazon SNS, che disattiverà un'origine dati nel caso in cui venga soddisfatto un criterio di soglia. **Nota** I dati di utilizzo in AWS Budgets non sono in tempo reale e possono subire ritardi fino a 8 ore. ## Eliminazione di un'origine dati Quando elimini un'origine dati, Amazon OpenSearch Service la rimuove dal tuo dominio o dalla tua raccolta. OpenSearch Il servizio rimuove anche gli indici associati alla fonte di dati. I tuoi dati transazionali non vengono eliminati dall'altro Servizio AWS, ma l'altro Servizio AWS non invia nuovi dati al Servizio. OpenSearch Puoi eliminare l'integrazione di un'origine dati utilizzando l'API Console di gestione AWS o il OpenSearch Service. ### Console di gestione AWS **Per eliminare un'origine dati Amazon S3** 1. Accedi alla console di Amazon OpenSearch Service all'indirizzo[https://console.aws.amazon.com/aos/](https://console.aws.amazon.com/aos/). 1. Dal riquadro di navigazione a sinistra, scegli **Domini**. 1. Seleziona il dominio per il quale desideri eliminare un'origine dati. Si apre la pagina dei dettagli del dominio. Scegli la scheda **Connessioni** sotto le informazioni generali e trova la sezione **Direct Query**. 1. Seleziona l'origine dati che desideri eliminare, scegli **Elimina** e conferma l'eliminazione. **Per eliminare un'origine dati CloudWatch Logs o Security Lake** 1. Accedi alla console di Amazon OpenSearch Service all'indirizzo[https://console.aws.amazon.com/aos/](https://console.aws.amazon.com/aos/). 1. Dal riquadro di navigazione a sinistra, scegli **Gestione centrale**, quindi **Origini dati connesse**. 1. Seleziona l'origine dati che desideri eliminare, scegli **Elimina** e conferma l'eliminazione. ### OpenSearch API di servizio Per eliminare un'origine dati Amazon S3, utilizza l'operazione [DeleteDataSource](https://docs.aws.amazon.com/opensearch-service/latest/APIReference/API_DeleteDataSource.html)API. ``` POST https://es.region.amazonaws.com/2021-01-01/opensearch/domain/domain-name/dataSource/data-source-name ``` Per eliminare un'origine dati CloudWatch Logs o Security Lake, utilizza l'operazione [DeleteDirectQueryDataSource](https://docs.aws.amazon.com/opensearch-service/latest/APIReference/API_DeleteDirectQueryDataSource.html)API. # Comandi SQL e PPL supportati OpenSearch SQL e OpenSearch Pipeline Processing Language (PPL) sono linguaggi per l'interrogazione, l'analisi e l'elaborazione dei dati in OpenSearch Logs Insights e Security Lake. CloudWatch Puoi usare OpenSearch SQL e OpenSearch PPL in OpenSearch Discover per interrogare i dati all'interno di CloudWatch Logs, Amazon S3 o Security Lake. CloudWatch Logs Insights supporta anche i linguaggi di query OpenSearch PPL e OpenSearch SQL, oltre a Logs Insights QL, un linguaggio di query creato appositamente per l'analisi dei log. CloudWatch + **OpenSearch SQL: OpenSearch SQL** offre un'opzione familiare se sei abituato a lavorare con database relazionali. OpenSearch SQL offre un sottoinsieme di funzionalità SQL, il che lo rende una buona scelta per eseguire query ad hoc e attività di analisi dei dati. Con OpenSearch SQL, è possibile utilizzare comandi come SELECT, FROM, WHERE, GROUP BY, HAVING e vari altri comandi e funzioni SQL disponibili in SQL. È possibile eseguire JOINs più tabelle (o gruppi di log), correlare i dati tra tabelle (o gruppi di log) utilizzando sottoquery e utilizzare il ricco set di funzioni SQL JSON, matematiche, di stringa, condizionali e di altro tipo per eseguire analisi approfondite sui dati di registro e di sicurezza. + **OpenSearch PPL (Piped Processing Language):** con OpenSearch PPL, è possibile recuperare, interrogare e analizzare i dati utilizzando comandi concatenati, semplificando la comprensione e la composizione di query complesse. La sua sintassi è basata sulle pipe Unix e consente il concatenamento di comandi per trasformare ed elaborare i dati. Con PPL, è possibile filtrare e aggregare i dati e utilizzare comandi come JOINs sottoquery, LOOKUP e un ricco set di funzioni matematiche, di stringhe, di data, condizionali e di altro tipo per l'analisi. Sebbene la maggior parte dei comandi nei linguaggi di query OpenSearch PPL e OpenSearch SQL siano comuni a CloudWatch Logs and OpenSearch, esistono alcune differenze nel set di comandi e funzioni supportato in ciascuno di questi servizi. Per ulteriori dettagli, consultate le tabelle nelle pagine seguenti. **** + [Comandi e funzioni OpenSearch SQL supportati](supported-directquery-sql.md) + [Informazioni aggiuntive per gli utenti di CloudWatch Logs Insights che utilizzano SQL OpenSearch](supported-directquery-sql.md#supported-sql-for-multi-log-queries) + [Restrizioni SQL generali](supported-directquery-sql.md#general-sql-restrictions) + [Comandi PPL supportati](supported-ppl.md) + [Informazioni aggiuntive per gli utenti di CloudWatch Logs Insights che utilizzano PPL OpenSearch](supported-ppl.md#supported-ppl-for-cloudwatch-users) # Comandi e funzioni OpenSearch SQL supportati Le seguenti tabelle di riferimento mostrano quali comandi SQL sono supportati in OpenSearch Discover per l'interrogazione dei dati in Amazon S3, Security Lake CloudWatch o Logs e quali comandi SQL sono supportati CloudWatch in Logs Insights. La sintassi SQL supportata in CloudWatch Logs Insights e quella supportata in OpenSearch Discover per l'interrogazione dei log sono le stesse e viene citata CloudWatch come Logs nelle tabelle seguenti. CloudWatch **Nota** OpenSearch include anche il supporto SQL per l'interrogazione dei dati che vengono inseriti e archiviati negli indici. OpenSearch [Questo dialetto SQL è diverso dall'SQL utilizzato nelle query dirette e viene denominato SQL sugli indici. OpenSearch ](https://opensearch.org/docs/latest/search-plugins/sql/sql/index/) **Topics** + [Comandi](#supported-sql-data-retrieval) + [Funzioni](#supported-sql-functions) + [Restrizioni SQL generali](#general-sql-restrictions) + [Informazioni aggiuntive per gli utenti di CloudWatch Logs Insights che utilizzano SQL OpenSearch](#supported-sql-for-multi-log-queries) ## Comandi **Nota** Nella colonna dei comandi di esempio, sostituisci se necessario `` a seconda della fonte di dati su cui stai interrogando. Comando di esempio: `SELECT Body , Operation FROM ` Se stai eseguendo una query su Amazon S3 o Security Lake, usa: `SELECT Body , Operation FROM table_name` Se stai interrogando i CloudWatch log, usa: `SELECT Body , Operation FROM `LogGroupA`` | Comando | Description | CloudWatch Registri | Simple Storage Service (Amazon S3) | Lago di sicurezza | Esempio di comando | | --- | --- | --- | --- | --- | --- | | [Clausola SELECT](#supported-sql-select) | Visualizza i valori proiettati. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    method,
    status 
FROM
| | [Clausola WHERE](#supported-sql-where) | Filtra gli eventi di registro in base ai criteri di campo forniti. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    * 
FROM 
    
WHERE 
    status = 100
| | [Clausola GROUP BY](#supported-sql-group-by) | I gruppi registrano gli eventi in base alla categoria e trovano la media in base alle statistiche. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    method,
    status,
    COUNT(*) AS request_count,
    SUM(bytes) AS total_bytes 
FROM 
     
GROUP BY 
    method, 
    status
| | [Clausola HAVING](#supported-sql-having) | Filtra i risultati in base alle condizioni di raggruppamento. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    method,
    status,
    COUNT(*) AS request_count,
    SUM(bytes) AS total_bytes 
FROM 
     
GROUP BY 
    method,
    status
HAVING 
    COUNT(*) > 5
| | [Clausola ORDER BY](#supported-sql-order-by) | Ordina i risultati in base ai campi della clausola order. È possibile ordinare in ordine decrescente o crescente. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    * 
FROM 
     
ORDER BY 
    status DESC
| | [Clausola JOIN](#supported-sql-join) ( `INNER` \$1 `CROSS` \$1 `LEFT` `OUTER` ) | Unisce i risultati di due tabelle basate su campi comuni. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato (è necessario utilizzare `Inner` e `Left Outer` parole chiave per il join; in un'istruzione SELECT è supportata una sola operazione JOIN) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportata (è necessario utilizzare le parole chiave Inner, Left Outer e Cross per l'unione) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato (è necessario utilizzare le parole chiave Inner, Left Outer e Cross per l'unione) | 
SELECT 
    A.Body,
    B.Timestamp
FROM 
     AS A 
INNER JOIN 
     AS B 
    ON A.`requestId` = B.`requestId`
| | [Clausola LIMIT](#supported-sql-limit) | Limita i risultati alle prime N righe. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    * 
FROM 
     
LIMIT 
    10
| | [Clausola CASE](#supported-sql-case) | Valuta le condizioni e restituisce un valore quando viene soddisfatta la prima condizione. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT
    method,
    status,
    CASE
        WHEN status BETWEEN 100 AND 199 THEN 'Informational'
        WHEN status BETWEEN 200 AND 299 THEN 'Success'
        WHEN status BETWEEN 300 AND 399 THEN 'Redirection'
        WHEN status BETWEEN 400 AND 499 THEN 'Client Error'
        WHEN status BETWEEN 500 AND 599 THEN 'Server Error'
        ELSE 'Unknown Status'
    END AS status_category,
    CASE method
        WHEN 'GET' THEN 'Read Operation'
        WHEN 'POST' THEN 'Create Operation'
        WHEN 'PUT' THEN 'Update Operation'
        WHEN 'PATCH' THEN 'Partial Update Operation'
        WHEN 'DELETE' THEN 'Delete Operation'
        ELSE 'Other Operation'
    END AS operation_type,
    bytes,
    datetime
FROM
| | [Espressione di tabella comune](#supported-sql-cte) | Crea un set di risultati temporaneo denominato all'interno di un'istruzione SELECT, INSERT, UPDATE, DELETE o MERGE. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/negative_icon.svg)Non supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
WITH RequestStats AS (
    SELECT 
        method,
        status,
        bytes,
        COUNT(*) AS request_count
    FROM 
        tableName
    GROUP BY 
        method,
        status,
        bytes
)
SELECT 
    method,
    status,
    bytes,
    request_count 
FROM 
    RequestStats 
WHERE 
    bytes > 1000
| | [EXPLAIN](#supported-sql-explain) | Visualizza il piano di esecuzione di un'istruzione SQL senza eseguirla effettivamente. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/negative_icon.svg)Non supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
EXPLAIN
SELECT 
    k,
    SUM(v)
FROM 
    VALUES 
        (1, 2),
        (1, 3) AS t(k, v)
GROUP BY 
    k
| | [Clausola LATERAL SUBQUERY](#supported-sql-lateral-subquery) | Consente a una sottoquery nella clausola FROM di fare riferimento alle colonne degli elementi precedenti nella stessa clausola FROM. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/negative_icon.svg)Non supportata | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
 SELECT 
    * 
FROM 
    tableName
LATERAL (
    SELECT 
        * 
    FROM 
        t2 
    WHERE 
        t1.c1 = t2.c1
)
| | [Clausola LATERAL VIEW](#supported-sql-lateral-view) | Genera una tabella virtuale applicando una funzione di generazione di tabelle a ciascuna riga di una tabella base. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/negative_icon.svg)Non supportata | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    * 
FROM 
    tableName
LATERAL VIEW 
    EXPLODE(ARRAY(30, 60)) tableName AS c_age
LATERAL VIEW 
    EXPLODE(ARRAY(40, 80)) AS d_age
| | [Predicato LIKE](#supported-sql-like-predicate) | Corrisponde a una stringa in base a uno schema utilizzando caratteri jolly. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
 SELECT 
    method,
    status,
    request,
    host 
FROM 
     
WHERE 
    method LIKE 'D%'
| | [OFFSET](#supported-sql-offset) | Specificate il numero di righe da saltare prima di iniziare a restituire le righe della query. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato se utilizzato insieme a una LIMIT clausola in una query. Esempio:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/supported-directquery-sql.html) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
 SELECT 
    method,
    status,
    bytes,
    datetime 
FROM 
     
ORDER BY 
    datetime
OFFSET 
    10
| | [Clausola PIVOT](#supported-sql-pivot) | Trasforma le righe in colonne, ruotando i dati da un formato basato su righe a un formato basato su colonne. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/negative_icon.svg)Non supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    * 
FROM 
    (
        SELECT 
            method,
            status,
            bytes
        FROM 
            
    ) AS SourceTable 
PIVOT 
(
    SUM(bytes) 
    FOR method IN ('GET', 'POST', 'PATCH', 'PUT', 'DELETE')
) AS PivotTable
| | [Operatori su set](#supported-sql-set) | Combina i risultati di due o più istruzioni SELECT (ad esempio, UNION, INTERSECT, EXCEPT). | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    method,
    status,
    bytes
FROM 
    
WHERE 
    status = '416'

UNION

SELECT 
    method,
    status,
    bytes
FROM 
    
WHERE 
    bytes > 20000
| | [Clausola SORT BY](#supported-sql-sort-by) | Speciifica l'ordine in cui restituire i risultati della query. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    method,
    status,
    bytes
FROM 
    
SORT BY 
    bytes DESC
| | [UNPIVOT](#supported-sql-unpivot) | Trasforma le colonne in righe, ruotando i dati da un formato basato su colonne a un formato basato su righe. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/negative_icon.svg)Non supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
 SELECT 
    status,
    REPLACE(method, '_bytes', '') AS request_method,
    bytes,
    datetime 
FROM 
    PivotedData 
UNPIVOT 
(
    bytes 
    FOR method IN 
    (
        GET_bytes,
        POST_bytes,
        PATCH_bytes,
        PUT_bytes,
        DELETE_bytes
    )
) AS UnpivotedData
| ## Funzioni **Nota** Nella colonna dei comandi di esempio, sostituisci `` se necessario a seconda della fonte di dati su cui stai interrogando. Comando di esempio: `SELECT Body , Operation FROM ` Se stai eseguendo una query su Amazon S3 o Security Lake, usa: `SELECT Body , Operation FROM table_name` Se stai interrogando i CloudWatch log, usa: `SELECT Body , Operation FROM `LogGroupA`` | Grammar SQL disponibile | Description | CloudWatch Registri | Simple Storage Service (Amazon S3) | Lago di sicurezza | Esempio di comando | | --- | --- | --- | --- | --- | --- | | [Funzioni stringa](#supported-sql-string) | Funzioni integrate in grado di manipolare e trasformare stringhe e dati di testo all'interno di query SQL. Ad esempio, convertire maiuscole e minuscole, combinare stringhe, estrarre parti e pulire il testo. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    UPPER(method) AS upper_method,
    LOWER(host) AS lower_host 
FROM
| | [Funzioni di data e ora](#supported-sql-date-time) | Funzioni integrate per la gestione e la trasformazione dei dati di data e ora nelle query. ******Ad esempio, **date\$1add, date\$1format, datediff e current\$1date**.****** | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    TO_TIMESTAMP(datetime) AS timestamp,
    TIMESTAMP_SECONDS(UNIX_TIMESTAMP(datetime)) AS from_seconds,
    UNIX_TIMESTAMP(datetime) AS to_unix,
    FROM_UTC_TIMESTAMP(datetime, 'PST') AS to_pst,
    TO_UTC_TIMESTAMP(datetime, 'EST') AS from_est 
FROM
| | [Funzioni di aggregazione](#supported-sql-aggregate) | Funzioni integrate che eseguono calcoli su più righe per produrre un unico valore riepilogato. **Ad esempio, **sum**, **count**, **avg**, **max** e min.** | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    COUNT(*) AS total_records,
    COUNT(DISTINCT method) AS unique_methods,
    SUM(bytes) AS total_bytes,
    AVG(bytes) AS avg_bytes,
    MIN(bytes) AS min_bytes,
    MAX(bytes) AS max_bytes 
FROM
| | [Funzioni condizionali](#supported-sql-conditional) | Funzioni integrate che eseguono azioni in base a condizioni specifiche o che valutano le espressioni in modo condizionale. Ad esempio, **CASE** e **IF**. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    CASE 
        WHEN method = 'GET' AND bytes < 1000 THEN 'Small Read'
        WHEN method = 'POST' AND bytes > 10000 THEN 'Large Write'
        WHEN status >= 400 OR bytes = 0 THEN 'Problem'
        ELSE 'Normal'
    END AS request_type 
FROM
| | [Funzioni JSON](#supported-sql-json) | Funzioni integrate per l'analisi, l'estrazione, la modifica e l'interrogazione di dati in formato JSON all'interno delle query SQL (ad esempio, from\$1json, to\$1json, get\$1json\$1object, json\$1tuple) che consentono la manipolazione delle strutture JSON nei set di dati. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    FROM_JSON(
        @message, 
        'STRUCT<
            host: STRING,
            user-identifier: STRING,
            datetime: STRING,
            method: STRING,
            status: INT,
            bytes: INT
        >'
    ) AS parsed_json 
FROM
| | [Funzioni di array](#supported-sql-array) | Funzioni integrate per lavorare con colonne di tipo array nelle query SQL, che consentono operazioni come l'accesso, la modifica e l'analisi dei dati dell'array (ad esempio, size, explode, array\$1contains). | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    scores,
    size(scores) AS length,
    array_contains(scores, 90) AS has_90 
FROM
| | [Funzioni finestra](#supported-sql-window) | Funzioni integrate che eseguono calcoli su un insieme specifico di righe relative alla riga (finestra) corrente, che consentono operazioni come la classificazione, i totali correnti e le medie mobili (ad esempio, ROW\$1NUMBER, RANK, LAG, LEAD) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
 SELECT 
    field1,
    field2,
    RANK() OVER (ORDER BY field2 DESC) AS field2Rank 
FROM
| | [Funzioni di conversione](#supported-sql-conversion) | Funzioni integrate per la conversione dei dati da un tipo all'altro all'interno delle query SQL, che consentono trasformazioni dei tipi di dati e conversioni di formato (ad esempio, CAST, TO\$1DATE, TO\$1TIMESTAMP, BINARY) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    CAST('123' AS INT) AS converted_number,
    CAST(123 AS STRING) AS converted_string 
FROM
| | [Funzioni di predicato](#supported-sql-predicate) | Funzioni integrate che valutano le condizioni e restituiscono valori booleani (true/false) in base a criteri o modelli specificati (ad esempio, IN, LIKE, BETWEEN, IS NULL, EXISTS) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    * 
FROM 
     
WHERE 
    id BETWEEN 50000 AND 75000
| | [Funzioni della mappa](#supported-sql-map) | Applica una funzione specificata a ogni elemento di una raccolta, trasformando i dati in un nuovo set di valori. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/negative_icon.svg)Non supportata | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    MAP_FILTER(
        MAP(
            'method', method,
            'status', CAST(status AS STRING),
            'bytes', CAST(bytes AS STRING)
        ),
        (k, v) -> k IN ('method', 'status') AND v != 'null'
    ) AS filtered_map 
FROM 
     
WHERE 
    status = 100
| | [Funzioni matematiche](#supported-sql-math) | Esegue operazioni matematiche su dati numerici, ad esempio il calcolo di medie, somme o valori trigonometrici. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    bytes,
    bytes + 1000 AS added,
    bytes - 1000 AS subtracted,
    bytes * 2 AS doubled,
    bytes / 1024 AS kilobytes,
    bytes % 1000 AS remainder 
FROM
| | [Funzioni di gruppo multi-log](#multi-log-queries) | Consente agli utenti di specificare più gruppi di log in un'istruzione SQL SELECT | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | Non applicabile | Non applicabile | 
SELECT 
    lg1.Column1,
    lg1.Column2 
FROM 
    `logGroups(logGroupIdentifier: ['LogGroup1', 'LogGroup2'])` AS lg1 
WHERE 
    lg1.Column3 = "Success"
| | [Funzioni del generatore](#supported-sql-generator) | Crea un oggetto iteratore che produce una sequenza di valori, che consente un utilizzo efficiente della memoria in set di dati di grandi dimensioni. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/negative_icon.svg)Non supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
SELECT 
    explode(array(10, 20))
| ## Restrizioni SQL generali Le seguenti restrizioni si applicano all'utilizzo di OpenSearch SQL with CloudWatch Logs, Amazon S3 e Security Lake. 1. È possibile utilizzare una sola operazione JOIN in un'istruzione SELECT. 1. È supportato solo un livello di sottoquery annidate. 1. Le query di istruzioni multiple separate da punto e virgola non sono supportate. 1. Le query contenenti nomi di campo identici ma che differiscono solo per maiuscole e minuscole (ad esempio field1 e) non sono supportate. FIELD1 Ad esempio, le seguenti query non sono supportate: ``` Select AWSAccountId, awsaccountid from LogGroup ``` Tuttavia, la seguente query è dovuta al fatto che il nome del campo (@logStream) è identico in entrambi i gruppi di log: ``` Select a.`@logStream`, b.`@logStream` from Table A INNER Join Table B on a.id = b.id ``` 1. Le funzioni e le espressioni devono operare sui nomi dei campi e far parte di un'istruzione SELECT con un gruppo di log specificato nella clausola FROM. Ad esempio, questa query non è supportata: ``` SELECT cos(10) FROM LogGroup ``` Questa interrogazione è supportata: ``` SELECT cos(field1) FROM LogGroup ``` ## Informazioni aggiuntive per gli utenti di CloudWatch Logs Insights che utilizzano SQL OpenSearch CloudWatch Logs supporta le query OpenSearch SQL nella console, nell'API e nella CLI di Logs Insights. Supporta la maggior parte dei comandi, tra cui SELECT, FROM, WHERE, GROUP BY, HAVING, JOINS e le query annidate, oltre a funzioni JSON, matematiche, stringhe e condizionali. Tuttavia, CloudWatch Logs supporta solo operazioni di lettura, quindi non consente istruzioni DDL o DML. Consulta le tabelle nelle sezioni precedenti per un elenco completo dei comandi e delle funzioni supportati. ### Funzioni di gruppo multi-log CloudWatch Logs Insights supporta la possibilità di interrogare più gruppi di log. Per risolvere questo caso d'uso in SQL, è possibile utilizzare il `logGroups` comando. Questo comando è specifico per l'interrogazione dei dati in CloudWatch Logs Insights che coinvolge uno o più gruppi di log. Utilizzate questa sintassi per interrogare più gruppi di log specificandoli nel comando, invece di scrivere una query per ciascuno dei gruppi di log e combinarli con un comando. `UNION` Sintassi: ``` `logGroups( logGroupIdentifier: ['LogGroup1','LogGroup2', ...'LogGroupn'] ) ``` In questa sintassi, è possibile specificare fino a 50 gruppi di log nel parametro. `logGroupIndentifier` Per fare riferimento ai gruppi di log in un account di monitoraggio, usa ARNs al posto dei `LogGroup` nomi. Query di esempio: ``` SELECT LG1.Column1, LG1.Column2 from `logGroups( logGroupIdentifier: ['LogGroup1', 'LogGroup2'] )` as LG1 WHERE LG1.Column1 = 'ABC' ``` La seguente sintassi che coinvolge più gruppi di log dopo l'`FROM`istruzione non è supportata durante l' CloudWatch interrogazione dei log: ``` SELECT Column1, Column2 FROM 'LogGroup1', 'LogGroup2', ...'LogGroupn' WHERE Column1 = 'ABC' ``` ### Restrizioni Quando usi i comandi SQL o PPL, racchiudi alcuni campi tra i backtick per interrogarli. I backtick sono obbligatori per i campi con caratteri speciali (non alfabetici e non numerici). Ad esempio, racchiudi e inserisci i contrassegni. `@message` `Operation.Export,` `Test::Field` Non è necessario racchiudere colonne con nomi puramente alfabetici nei backtick. Query di esempio con campi semplici: ``` SELECT SessionToken, Operation, StartTime FROM `LogGroup-A` LIMIT 1000; ``` Stessa query con i backtick aggiunti: ``` SELECT `SessionToken`, `Operation`, `StartTime` FROM `LogGroup-A` LIMIT 1000; ``` Per ulteriori restrizioni generali non specifiche dei CloudWatch registri, consulta. [Restrizioni SQL generali](#general-sql-restrictions) ### Esempi di domande e quote **Nota** Quanto segue si applica sia agli utenti di CloudWatch Logs Insights che agli utenti che effettuano query sui dati. OpenSearch CloudWatch Per esempi di query SQL che puoi utilizzare nei CloudWatch log, consulta la sezione **Query salvate e di esempio** nella console Amazon CloudWatch Logs Insights per alcuni esempi. Per informazioni sui limiti che si applicano all'interrogazione di CloudWatch Logs from OpenSearch Service, consulta [CloudWatch Logs quotas nella Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html) User Guide. I limiti riguardano il numero di gruppi di CloudWatch log su cui è possibile eseguire query, il numero massimo di query simultanee che è possibile eseguire, il tempo massimo di esecuzione delle query e il numero massimo di righe restituite nei risultati. I limiti sono gli stessi indipendentemente dalla lingua utilizzata per l'interrogazione dei log (vale a dire OpenSearch PPL, SQL e CloudWatch Logs Insights). ### Comandi SQL **Topics** + [Funzioni stringa](#supported-sql-string) + [Funzioni di data e ora](#supported-sql-date-time) + [Funzioni di aggregazione](#supported-sql-aggregate) + [Funzioni condizionali](#supported-sql-conditional) + [Funzioni JSON](#supported-sql-json) + [Funzioni di array](#supported-sql-array) + [Funzioni finestra](#supported-sql-window) + [Funzioni di conversione](#supported-sql-conversion) + [Funzioni di predicato](#supported-sql-predicate) + [Funzioni della mappa](#supported-sql-map) + [Funzioni matematiche](#supported-sql-math) + [Funzioni del generatore](#supported-sql-generator) + [Clausola SELECT](#supported-sql-select) + [Clausola WHERE](#supported-sql-where) + [Clausola GROUP BY](#supported-sql-group-by) + [Clausola HAVING](#supported-sql-having) + [Clausola ORDER BY](#supported-sql-order-by) + [Clausola JOIN](#supported-sql-join) + [Clausola LIMIT](#supported-sql-limit) + [Clausola CASE](#supported-sql-case) + [Espressione di tabella comune](#supported-sql-cte) + [EXPLAIN](#supported-sql-explain) + [Clausola LATERAL SUBQUERY](#supported-sql-lateral-subquery) + [Clausola LATERAL VIEW](#supported-sql-lateral-view) + [Predicato LIKE](#supported-sql-like-predicate) + [OFFSET](#supported-sql-offset) + [Clausola PIVOT](#supported-sql-pivot) + [Operatori su set](#supported-sql-set) + [Clausola SORT BY](#supported-sql-sort-by) + [UNPIVOT](#supported-sql-unpivot) #### Funzioni stringa **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) **** | Funzione | Description | | --- | --- | | ascii (str) | Restituisce il valore numerico del primo carattere di. str | | base64 (bin) | Converte l'argomento da un file binario bin a una stringa in base 64. | | lunghezza\$1bit (expr) | Restituisce la lunghezza in bit dei dati di stringa o il numero di bit dei dati binari. | | btrim (str) | Rimuove i caratteri spaziali iniziali e finali da. str | | btrim (str, trimStr) | Rimuovi i caratteri iniziali e finali trimStr da. str | | char (expr) | Restituisce il carattere ASCII con l'equivalente binario di. expr Se n è maggiore di 256 il risultato è equivalente a chr (n% 256) | | lunghezza del carattere (expr) | Restituisce la lunghezza dei caratteri dei dati della stringa o il numero di byte dei dati binari. La lunghezza dei dati della stringa include gli spazi finali. La lunghezza dei dati binari include gli zeri binari. | | carattere\$1lunghezza (expr) | Restituisce la lunghezza dei caratteri dei dati della stringa o il numero di byte dei dati binari. La lunghezza dei dati della stringa include gli spazi finali. La lunghezza dei dati binari include gli zeri binari. | | chr (expr) | Restituisce il carattere ASCII con l'equivalente binario di. expr Se n è maggiore di 256 il risultato è equivalente a chr (n% 256) | | concat\$1ws (sep [, str \$1 array (str)] \$1) | Restituisce la concatenazione delle stringhe separate da, saltando i valori nulli. sep | | contiene (sinistra, destra) | Restituisce un valore booleano. Il valore è True se la parte destra si trova all'interno della sinistra. Restituisce NULL se una delle espressioni di input è NULL. Altrimenti, restituisce False. Sia la sinistra che la destra devono essere di tipo STRING o BINARY. | | decode (bin, set di caratteri) | Decodifica il primo argomento utilizzando il set di caratteri del secondo argomento. | | decode (expr, search, result [, search, result]... [, predefinito]) | Confronta expr con ogni valore di ricerca in ordine. Se expr è uguale a un valore di ricerca, decode restituisce il risultato corrispondente. Se non viene trovata alcuna corrispondenza, restituisce il valore predefinito. Se il valore predefinito viene omesso, restituisce null. | | elt (n, input1, input2,...) | Restituisce il n -esimo input, ad esempio restituisce quando è 2. input2 n | | encode (str, charset) | Codifica il primo argomento utilizzando il set di caratteri del secondo argomento. | | termina con (sinistra, destra) | Restituisce un valore booleano. Il valore è True se la parte sinistra termina con la destra. Restituisce NULL se una delle espressioni di input è NULL. Altrimenti, restituisce False. Sia la sinistra che la destra devono essere di tipo STRING o BINARY. | | find\$1in\$1set (str, str\$1array) | Restituisce l'indice (basato su 1) della stringa specificata () nell'elenco delimitato da virgole (str). str\$1array Restituisce 0, se la stringa non è stata trovata o se la stringa specificata () str contiene una virgola. | | format\$1number (espr 1, espr 2) | Formatta il numero expr1 come '\$1, \$1\$1\$1, \$1\$1\$1.\$1\$1', arrotondato al numero decimale. expr2 Se expr2 è 0, il risultato non ha punti decimali o parti frazionarie. expr2accetta anche un formato specificato dall'utente. Questo dovrebbe funzionare come FORMAT di MySQL. | | format\$1string (strfmt, obj,...) | Restituisce una stringa formattata da stringhe di formato in stile printf. | | initcap (str) | Restituisce str con la prima lettera di ogni parola in maiuscolo. Tutte le altre lettere sono in minuscolo. Le parole sono delimitate da spazi bianchi. | | instr (str, substr) | Restituisce l'indice (a base 1) della prima occorrenza di in. substr str | | lcase (str) | Restituisce str con tutti i caratteri cambiati in minuscolo. | | sinistra (str, len) | Restituisce i caratteri più a sinistra len (lenpuò essere di tipo stringa) dalla stringastr, se len è minore o uguale a 0 il risultato è una stringa vuota. | | len (espr) | Restituisce la lunghezza dei caratteri dei dati della stringa o il numero di byte dei dati binari. La lunghezza dei dati della stringa include gli spazi finali. La lunghezza dei dati binari include gli zeri binari. | | lunghezza (expr) | Restituisce la lunghezza dei caratteri dei dati della stringa o il numero di byte dei dati binari. La lunghezza dei dati della stringa include gli spazi finali. La lunghezza dei dati binari include gli zeri binari. | | levenshtein (str1, str2 [, soglia]) | Restituisce la distanza di Levenshtein tra le due stringhe date. Se la soglia è impostata e la distanza è maggiore, restituisce -1. | | localizza (substr, str [, pos]) | Restituisce la posizione della prima occorrenza di substr in str dopo la posizionepos. Il valore dato pos e quello restituito sono basati su 1. | | inferiore (str) | Restituisce str con tutti i caratteri cambiati in minuscolo. | | lpad (str, len [, pad]) | Restituiscestr, imbottito a sinistra con pad una lunghezza di. len Se str è più lungo dilen, il valore restituito viene abbreviato in caratteri o byte. len Se non pad è specificato, str verrà aggiunto a sinistra con caratteri spaziali se si tratta di una stringa di caratteri e con zeri se si tratta di una sequenza di byte. | | ltrim (str) | Rimuove i caratteri spaziali iniziali da. str | | lun\$1check (str) | Verifica che una stringa di cifre sia valida secondo l'algoritmo di Luhn. Questa funzione di checksum è ampiamente utilizzata sui numeri di carte di credito e sui numeri di identificazione governativi per distinguere i numeri validi da quelli digitati erroneamente. | | maschera (input [, upperChar, lowerChar, DigitChar, OtherChar]) | maschera il valore di stringa dato. La funzione sostituisce i caratteri con 'X' o 'x' e i numeri con 'n'. Ciò può essere utile per creare copie di tabelle con informazioni riservate rimosse. | | lunghezza\$1ottetto (expr) | Restituisce la lunghezza in byte dei dati di stringa o il numero di byte dei dati binari. | | overlay (input, replace, pos [, len]) | Sostituisci input con replace quello inizia da pos ed è di lunghezza. len | | posizione (substr, str [, pos]) | Restituisce la posizione della prima occorrenza di substr in str dopo la posizionepos. Il valore dato pos e quello restituito sono basati su 1. | | printf (strfmt, obj,...) | Restituisce una stringa formattata da stringhe di formato in stile printf. | | regexp\$1count (str, regexp) | Restituisce un conteggio del numero di volte in cui il modello di espressione regolare regexp viene trovato nella stringa. str | | regexp\$1extract (str, regexp [, idx]) | Estrai la prima stringa che corrisponde all'regexpespressione e str che corrisponde all'indice del gruppo regex. | | regexp\$1extract\$1all (str, regexp [, idx]) | Estrai tutte le stringhe str che corrispondono all'espressione e corrispondono all'indice del gruppo regex. regexp | | regexp\$1instr (str, regexp) | Cerca un'espressione regolare in una stringa e restituisce un numero intero che indica la posizione iniziale della sottostringa corrispondente. Le posizioni sono basate su 1, non su 0. Se non viene trovata alcuna corrispondenza, restituisce 0. | | regexp\$1replace (str, regexp, rep [, position]) | Sostituisce tutte le sottostringhe di quella corrispondenza con. str regexp rep | | regexp\$1substr (str, regexp) | Restituisce la sottostringa che corrisponde all'espressione regolare all'interno della stringa. regexp str Se l'espressione regolare non viene trovata, il risultato è nullo. | | ripetere (str, n) | Restituisce la stringa che ripete il valore di stringa dato n volte. | | sostituisci (str, cerca [, sostituisci]) | Sostituisce tutte le occorrenze di with. search replace | | destra (str, len) | Restituisce i caratteri più a destra len (lenpossono essere di tipo stringa) dalla stringastr, se len è minore o uguale a 0 il risultato è una stringa vuota. | | rpad (str, len [, pad]) | Restituiscestr, riempito a destra con una lunghezza pad di. len Se str è più lungo dilen, il valore restituito viene ridotto in caratteri. len Se non pad è specificato, str verrà aggiunto a destra con caratteri spaziali se si tratta di una stringa di caratteri e con zeri se si tratta di una stringa binaria. | | rtrim (str) | Rimuove i caratteri spaziali finali da. str | | frasi (str [, lang, country]) | Si str divide in una serie di parole. | | soundex (str) | Restituisce il codice Soundex della stringa. | | spazio (n) | Restituisce una stringa composta da n spazi. | | split (str, regex, limit) | Divide in base str alle occorrenze che corrispondono regex e restituisce un array con una lunghezza massima di limit | | split\$1part (str, delimiter, partNum) | Divide str per delimitatore e restituisce la parte della divisione richiesta (in base 1). Se un input è nullo, restituisce nullo. se non rientra nell'intervallo delle parti partNum suddivise, restituisce una stringa vuota. Se partNum è 0, genera un errore. Se partNum è negativo, le parti vengono contate all'indietro a partire dalla fine della stringa. Se delimiter è una stringa vuota, non str viene divisa. | | inizia con (sinistra, destra) | Restituisce un valore booleano. Il valore è True se la sinistra inizia con la destra. Restituisce NULL se una delle espressioni di input è NULL. Altrimenti, restituisce False. Sia la sinistra che la destra devono essere di tipo STRING o BINARY. | | substr (str, pos [, len]) | Restituisce la sottostringa str che inizia da pos ed è lungalen, oppure la porzione di matrice di byte che inizia da ed è lunga. pos len | | substr (str FROM pos [FOR len]]) | Restituisce la sottostringa str che inizia da pos ed è lungalen, oppure la porzione di matrice di byte che inizia da ed è lunga. pos len | | sottostringa (str, pos [, len]) | Restituisce la sottostringa str che inizia da pos ed è lungalen, oppure la porzione di matrice di byte che inizia da ed è lunga. pos len | | sottostringa (str FROM pos [FOR len]]) | Restituisce la sottostringa str che inizia da pos ed è lungalen, oppure la porzione di matrice di byte che inizia da ed è lunga. pos len | | substring\$1index (str, delim, count) | Restituisce la sottostringa str precedente count alle occorrenze del delimitatore. delim Se count è positivo, viene restituito tutto ciò che si trova a sinistra del delimitatore finale (contando da sinistra). Se count è negativo, viene restituito tutto ciò che si trova a destra del delimitatore finale (contando da destra). La funzione substring\$1index esegue una corrispondenza con distinzione tra maiuscole e minuscole durante la ricerca di. delim | | to\$1binary (str [, fmt]) | Converte l'input in un valore binario in base str al valore fornito. fmt fmtpuò essere una stringa letterale senza distinzione tra maiuscole e minuscole di «hex», «utf-8", «utf8" o «base64". Per impostazione predefinita, il formato binario per la conversione è «hex» se viene omesso. fmt La funzione restituisce NULL se almeno uno dei parametri di input è NULL. | | to\$1char (NumberExpr, FormatExpr) | Converti in una stringa basata su. numberExpr formatExpr Genera un'eccezione se la conversione fallisce. Il formato può essere composto dai seguenti caratteri, senza distinzione tra maiuscole e minuscole: '0' o '9': specifica una cifra prevista compresa tra 0 e 9. Una sequenza di 0 o 9 nella stringa di formato corrisponde a una sequenza di cifre nel valore di input, generando una stringa di risultato della stessa lunghezza della sequenza corrispondente nella stringa di formato. La stringa risultante viene riempita con zeri a sinistra se la sequenza 0/9 comprende più cifre della parte corrispondente del valore decimale, inizia con 0 ed è prima della virgola decimale. Altrimenti, viene riempito con spazi. '.' o 'D': specifica la posizione del punto decimale (facoltativo, consentito solo una volta). ',' o 'G': specifica la posizione del separatore di raggruppamento (migliaia) (,). Deve esserci uno 0 o 9 a sinistra e a destra di ogni separatore di raggruppamento. ' | | to\$1number (expr, fmt) | Converti la stringa 'expr' in un numero in base al formato di stringa 'fmt'. Genera un'eccezione se la conversione fallisce. Il formato può essere composto dai seguenti caratteri, senza distinzione tra maiuscole e minuscole: '0' o '9': specifica una cifra prevista compresa tra 0 e 9. Una sequenza di 0 o 9 nella stringa di formato corrisponde a una sequenza di cifre nella stringa di input. Se la sequenza 0/9 inizia con 0 e precede la virgola decimale, può corrispondere solo a una sequenza di cifre della stessa dimensione. Altrimenti, se la sequenza inizia con 9 o è dopo la virgola decimale, può corrispondere a una sequenza di cifre di dimensioni uguali o inferiori. '.' o 'D': specifica la posizione della virgola decimale (opzionale, consentita solo una volta). ',' o 'G': specifica la posizione del separatore di raggruppamento (migliaia) (,). Deve esserci uno 0 o 9 a sinistra e a destra di ogni separatore di raggruppamento. 'expr' deve corrispondere al separatore di raggruppamento pertinente alla dimensione del numero. ' | | to\$1varchar (NumberExpr, FormatExpr) | Converti in numberExpr una stringa basata su. formatExpr Genera un'eccezione se la conversione fallisce. Il formato può essere composto dai seguenti caratteri, senza distinzione tra maiuscole e minuscole: '0' o '9': specifica una cifra prevista compresa tra 0 e 9. Una sequenza di 0 o 9 nella stringa di formato corrisponde a una sequenza di cifre nel valore di input, generando una stringa di risultato della stessa lunghezza della sequenza corrispondente nella stringa di formato. La stringa risultante viene riempita con zeri a sinistra se la sequenza 0/9 comprende più cifre della parte corrispondente del valore decimale, inizia con 0 ed è prima della virgola decimale. Altrimenti, viene riempito con spazi. '.' o 'D': specifica la posizione del punto decimale (facoltativo, consentito solo una volta). ',' o 'G': specifica la posizione del separatore di raggruppamento (migliaia) (,). Deve esserci uno 0 o 9 a sinistra e a destra di ogni separatore di raggruppamento. ' | | tradurre (input, da, a) | Traduce la input stringa sostituendo i caratteri presenti nella from stringa con i caratteri corrispondenti nella to stringa. | | trim (str) | Rimuove i caratteri spaziali iniziali e finali da. str | | trim (ENTRAMBI DA str) | Rimuove i caratteri spaziali iniziali e finali da. str | | trim (LEADING FROM str) | Rimuove i caratteri spaziali iniziali dastr. | | trim (TRAILING FROM str) | Rimuove i caratteri spaziali finali da. str | | trim (trimStr FROM str) | Rimuovi i caratteri iniziali e finali da. trimStr str | | trim (SIA trimStr che str) | Rimuovi i caratteri iniziali e finali da. trimStr str | | trim (LEADING TrimStr FROM str) | Rimuovi i trimStr personaggi principali da. str | | trim (TRAILING TrimStr FROM str) | Rimuovi i caratteri finali trimStr da. str | | try\$1to\$1binary (str [, fmt]) | Questa è una versione speciale to\$1binary che esegue la stessa operazione, ma restituisce un valore NULL invece di generare un errore se la conversione non può essere eseguita. | | try\$1to\$1number (expr, fmt) | Converti la stringa 'expr' in un numero in base al formato della stringa. fmt Restituisce NULL se la stringa 'expr' non corrisponde al formato previsto. Il formato segue la stessa semantica della funzione to\$1number. | | o case (str) | Ritorna str con tutti i caratteri cambiati in maiuscolo. | | unbase64 (str) | Converte l'argomento da una stringa str in base 64 a un file binario. | | upper (str) | Ritorna str con tutti i caratteri cambiati in maiuscolo. | **Esempi** ``` -- ascii SELECT ascii('222'); +----------+ |ascii(222)| +----------+ | 50| +----------+ SELECT ascii(2); +--------+ |ascii(2)| +--------+ | 50| +--------+ -- base64 SELECT base64('Feathers'); +-----------------+ |base64(Feathers)| +-----------------+ | RmVhdGhlcnM=| +-----------------+ SELECT base64(x'537061726b2053514c'); +-----------------------------+ |base64(X'537061726B2053514C')| +-----------------------------+ | U3BhcmsgU1FM| +-----------------------------+ -- bit_length SELECT bit_length('Feathers'); +---------------------+ |bit_length(Feathers)| +---------------------+ | 64| +---------------------+ SELECT bit_length(x'537061726b2053514c'); +---------------------------------+ |bit_length(X'537061726B2053514C')| +---------------------------------+ | 72| +---------------------------------+ -- btrim SELECT btrim(' Feathers '); +----------------------+ |btrim( Feathers )| +----------------------+ | Feathers| +----------------------+ SELECT btrim(encode(' Feathers ', 'utf-8')); +-------------------------------------+ |btrim(encode( Feathers , utf-8))| +-------------------------------------+ | Feathers| +-------------------------------------+ SELECT btrim('Feathers', 'Fe'); +---------------------+ |btrim(Alphabet, Al)| +---------------------+ | athers| +---------------------+ SELECT btrim(encode('Feathers', 'utf-8'), encode('Al', 'utf-8')); +---------------------------------------------------+ |btrim(encode(Feathers, utf-8), encode(Al, utf-8))| +---------------------------------------------------+ | athers| +---------------------------------------------------+ -- char SELECT char(65); +--------+ |char(65)| +--------+ | A| +--------+ -- char_length SELECT char_length('Feathers '); +-----------------------+ |char_length(Feathers )| +-----------------------+ | 9 | +-----------------------+ SELECT char_length(x'537061726b2053514c'); +----------------------------------+ |char_length(X'537061726B2053514C')| +----------------------------------+ | 9| +----------------------------------+ SELECT CHAR_LENGTH('Feathers '); +-----------------------+ |char_length(Feathers )| +-----------------------+ | 9| +-----------------------+ SELECT CHARACTER_LENGTH('Feathers '); +----------------------------+ |character_length(Feathers )| +----------------------------+ | 9| +----------------------------+ -- character_length SELECT character_length('Feathers '); +----------------------------+ |character_length(Feathers )| +----------------------------+ | 9| +----------------------------+ SELECT character_length(x'537061726b2053514c'); +---------------------------------------+ |character_length(X'537061726B2053514C')| +---------------------------------------+ | 9| +---------------------------------------+ SELECT CHAR_LENGTH('Feathers '); +-----------------------+ |char_length(Feathers )| +-----------------------+ | 9| +-----------------------+ SELECT CHARACTER_LENGTH('Feathers '); +----------------------------+ |character_length(Feathers )| +----------------------------+ | 9| +----------------------------+ -- chr SELECT chr(65); +-------+ |chr(65)| +-------+ | A| +-------+ -- concat_ws SELECT concat_ws(' ', 'Fea', 'thers'); +------------------------+ |concat_ws( , Fea, thers)| +------------------------+ | Feathers| +------------------------+ SELECT concat_ws('s'); +------------+ |concat_ws(s)| +------------+ | | +------------+ SELECT concat_ws('/', 'foo', null, 'bar'); +----------------------------+ |concat_ws(/, foo, NULL, bar)| +----------------------------+ | foo/bar| +----------------------------+ SELECT concat_ws(null, 'Fea', 'thers'); +---------------------------+ |concat_ws(NULL, Fea, thers)| +---------------------------+ | NULL| +---------------------------+ -- contains SELECT contains('Feathers', 'Fea'); +--------------------------+ |contains(Feathers, Fea)| +--------------------------+ | true| +--------------------------+ SELECT contains('Feathers', 'SQL'); +--------------------------+ |contains(Feathers, SQL)| +--------------------------+ | false| +--------------------------+ SELECT contains('Feathers', null); +-------------------------+ |contains(Feathers, NULL)| +-------------------------+ | NULL| +-------------------------+ SELECT contains(x'537061726b2053514c', x'537061726b'); +----------------------------------------------+ |contains(X'537061726B2053514C', X'537061726B')| +----------------------------------------------+ | true| +----------------------------------------------+ -- decode SELECT decode(encode('abc', 'utf-8'), 'utf-8'); +---------------------------------+ |decode(encode(abc, utf-8), utf-8)| +---------------------------------+ | abc| +---------------------------------+ SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic'); +----------------------------------------------------------------------------------+ |decode(2, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle, Non domestic)| +----------------------------------------------------------------------------------+ | San Francisco| +----------------------------------------------------------------------------------+ SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic'); +----------------------------------------------------------------------------------+ |decode(6, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle, Non domestic)| +----------------------------------------------------------------------------------+ | Non domestic| +----------------------------------------------------------------------------------+ SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle'); +--------------------------------------------------------------------+ |decode(6, 1, Southlake, 2, San Francisco, 3, New Jersey, 4, Seattle)| +--------------------------------------------------------------------+ | NULL| +--------------------------------------------------------------------+ SELECT decode(null, 6, 'Fea', NULL, 'thers', 4, 'rock'); +-------------------------------------------+ |decode(NULL, 6, Fea, NULL, thers, 4, rock)| +-------------------------------------------+ | thers| +-------------------------------------------+ -- elt SELECT elt(1, 'scala', 'java'); +-------------------+ |elt(1, scala, java)| +-------------------+ | scala| +-------------------+ SELECT elt(2, 'a', 1); +------------+ |elt(2, a, 1)| +------------+ | 1| +------------+ -- encode SELECT encode('abc', 'utf-8'); +------------------+ |encode(abc, utf-8)| +------------------+ | [61 62 63]| +------------------+ -- endswith SELECT endswith('Feathers', 'ers'); +------------------------+ |endswith(Feathers, ers)| +------------------------+ | true| +------------------------+ SELECT endswith('Feathers', 'SQL'); +--------------------------+ |endswith(Feathers, SQL)| +--------------------------+ | false| +--------------------------+ SELECT endswith('Feathers', null); +-------------------------+ |endswith(Feathers, NULL)| +-------------------------+ | NULL| +-------------------------+ SELECT endswith(x'537061726b2053514c', x'537061726b'); +----------------------------------------------+ |endswith(X'537061726B2053514C', X'537061726B')| +----------------------------------------------+ | false| +----------------------------------------------+ SELECT endswith(x'537061726b2053514c', x'53514c'); +------------------------------------------+ |endswith(X'537061726B2053514C', X'53514C')| +------------------------------------------+ | true| +------------------------------------------+ -- find_in_set SELECT find_in_set('ab','abc,b,ab,c,def'); +-------------------------------+ |find_in_set(ab, abc,b,ab,c,def)| +-------------------------------+ | 3| +-------------------------------+ -- format_number SELECT format_number(12332.123456, 4); +------------------------------+ |format_number(12332.123456, 4)| +------------------------------+ | 12,332.1235| +------------------------------+ SELECT format_number(12332.123456, '##################.###'); +---------------------------------------------------+ |format_number(12332.123456, ##################.###)| +---------------------------------------------------+ | 12332.123| +---------------------------------------------------+ -- format_string SELECT format_string("Hello World %d %s", 100, "days"); +-------------------------------------------+ |format_string(Hello World %d %s, 100, days)| +-------------------------------------------+ | Hello World 100 days| +-------------------------------------------+ -- initcap SELECT initcap('Feathers'); +------------------+ |initcap(Feathers)| +------------------+ | Feathers| +------------------+ -- instr SELECT instr('Feathers', 'ers'); +--------------------+ |instr(Feathers, ers)| +--------------------+ | 6| +--------------------+ -- lcase SELECT lcase('Feathers'); +---------------+ |lcase(Feathers)| +---------------+ | feathers| +---------------+ -- left SELECT left('Feathers', 3); +------------------+ |left(Feathers, 3)| +------------------+ | Fea| +------------------+ SELECT left(encode('Feathers', 'utf-8'), 3); +---------------------------------+ |left(encode(Feathers, utf-8), 3)| +---------------------------------+ | [RmVh]| +---------------------------------+ -- len SELECT len('Feathers '); +---------------+ |len(Feathers )| +---------------+ | 9| +---------------+ SELECT len(x'537061726b2053514c'); +--------------------------+ |len(X'537061726B2053514C')| +--------------------------+ | 9| +--------------------------+ SELECT CHAR_LENGTH('Feathers '); +-----------------------+ |char_length(Feathers )| +-----------------------+ | 9| +-----------------------+ SELECT CHARACTER_LENGTH('Feathers '); +----------------------------+ |character_length(Feathers )| +----------------------------+ | 9| +----------------------------+ -- length SELECT length('Feathers '); +------------------+ |length(Feathers )| +------------------+ | 9| +------------------+ SELECT length(x'537061726b2053514c'); +-----------------------------+ |length(X'537061726B2053514C')| +-----------------------------+ | 9| +-----------------------------+ SELECT CHAR_LENGTH('Feathers '); +-----------------------+ |char_length(Feathers )| +-----------------------+ | 9| +-----------------------+ SELECT CHARACTER_LENGTH('Feathers '); +----------------------------+ |character_length(Feathers )| +----------------------------+ | 9| +----------------------------+ -- levenshtein SELECT levenshtein('kitten', 'sitting'); +----------------------------+ |levenshtein(kitten, sitting)| +----------------------------+ | 3| +----------------------------+ SELECT levenshtein('kitten', 'sitting', 2); +-------------------------------+ |levenshtein(kitten, sitting, 2)| +-------------------------------+ | -1| +-------------------------------+ -- locate SELECT locate('bar', 'foobarbar'); +-------------------------+ |locate(bar, foobarbar, 1)| +-------------------------+ | 4| +-------------------------+ SELECT locate('bar', 'foobarbar', 5); +-------------------------+ |locate(bar, foobarbar, 5)| +-------------------------+ | 7| +-------------------------+ SELECT POSITION('bar' IN 'foobarbar'); +-------------------------+ |locate(bar, foobarbar, 1)| +-------------------------+ | 4| +-------------------------+ -- lower SELECT lower('Feathers'); +---------------+ |lower(Feathers)| +---------------+ | feathers| +---------------+ -- lpad SELECT lpad('hi', 5, '??'); +---------------+ |lpad(hi, 5, ??)| +---------------+ | ???hi| +---------------+ SELECT lpad('hi', 1, '??'); +---------------+ |lpad(hi, 1, ??)| +---------------+ | h| +---------------+ SELECT lpad('hi', 5); +--------------+ |lpad(hi, 5, )| +--------------+ | hi| +--------------+ SELECT hex(lpad(unhex('aabb'), 5)); +--------------------------------+ |hex(lpad(unhex(aabb), 5, X'00'))| +--------------------------------+ | 000000AABB| +--------------------------------+ SELECT hex(lpad(unhex('aabb'), 5, unhex('1122'))); +--------------------------------------+ |hex(lpad(unhex(aabb), 5, unhex(1122)))| +--------------------------------------+ | 112211AABB| +--------------------------------------+ -- ltrim SELECT ltrim(' Feathers '); +----------------------+ |ltrim( Feathers )| +----------------------+ | Feathers | +----------------------+ -- luhn_check SELECT luhn_check('8112189876'); +----------------------+ |luhn_check(8112189876)| +----------------------+ | true| +----------------------+ SELECT luhn_check('79927398713'); +-----------------------+ |luhn_check(79927398713)| +-----------------------+ | true| +-----------------------+ SELECT luhn_check('79927398714'); +-----------------------+ |luhn_check(79927398714)| +-----------------------+ | false| +-----------------------+ -- mask SELECT mask('abcd-EFGH-8765-4321'); +----------------------------------------+ |mask(abcd-EFGH-8765-4321, X, x, n, NULL)| +----------------------------------------+ | xxxx-XXXX-nnnn-nnnn| +----------------------------------------+ SELECT mask('abcd-EFGH-8765-4321', 'Q'); +----------------------------------------+ |mask(abcd-EFGH-8765-4321, Q, x, n, NULL)| +----------------------------------------+ | xxxx-QQQQ-nnnn-nnnn| +----------------------------------------+ SELECT mask('AbCD123-@$#', 'Q', 'q'); +--------------------------------+ |mask(AbCD123-@$#, Q, q, n, NULL)| +--------------------------------+ | QqQQnnn-@$#| +--------------------------------+ SELECT mask('AbCD123-@$#'); +--------------------------------+ |mask(AbCD123-@$#, X, x, n, NULL)| +--------------------------------+ | XxXXnnn-@$#| +--------------------------------+ SELECT mask('AbCD123-@$#', 'Q'); +--------------------------------+ |mask(AbCD123-@$#, Q, x, n, NULL)| +--------------------------------+ | QxQQnnn-@$#| +--------------------------------+ SELECT mask('AbCD123-@$#', 'Q', 'q'); +--------------------------------+ |mask(AbCD123-@$#, Q, q, n, NULL)| +--------------------------------+ | QqQQnnn-@$#| +--------------------------------+ SELECT mask('AbCD123-@$#', 'Q', 'q', 'd'); +--------------------------------+ |mask(AbCD123-@$#, Q, q, d, NULL)| +--------------------------------+ | QqQQddd-@$#| +--------------------------------+ SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', 'o'); +-----------------------------+ |mask(AbCD123-@$#, Q, q, d, o)| +-----------------------------+ | QqQQdddoooo| +-----------------------------+ SELECT mask('AbCD123-@$#', NULL, 'q', 'd', 'o'); +--------------------------------+ |mask(AbCD123-@$#, NULL, q, d, o)| +--------------------------------+ | AqCDdddoooo| +--------------------------------+ SELECT mask('AbCD123-@$#', NULL, NULL, 'd', 'o'); +-----------------------------------+ |mask(AbCD123-@$#, NULL, NULL, d, o)| +-----------------------------------+ | AbCDdddoooo| +-----------------------------------+ SELECT mask('AbCD123-@$#', NULL, NULL, NULL, 'o'); +--------------------------------------+ |mask(AbCD123-@$#, NULL, NULL, NULL, o)| +--------------------------------------+ | AbCD123oooo| +--------------------------------------+ SELECT mask(NULL, NULL, NULL, NULL, 'o'); +-------------------------------+ |mask(NULL, NULL, NULL, NULL, o)| +-------------------------------+ | NULL| +-------------------------------+ SELECT mask(NULL); +-------------------------+ |mask(NULL, X, x, n, NULL)| +-------------------------+ | NULL| +-------------------------+ SELECT mask('AbCD123-@$#', NULL, NULL, NULL, NULL); +-----------------------------------------+ |mask(AbCD123-@$#, NULL, NULL, NULL, NULL)| +-----------------------------------------+ | AbCD123-@$#| +-----------------------------------------+ -- octet_length SELECT octet_length('Feathers'); +-----------------------+ |octet_length(Feathers)| +-----------------------+ | 8| +-----------------------+ SELECT octet_length(x'537061726b2053514c'); +-----------------------------------+ |octet_length(X'537061726B2053514C')| +-----------------------------------+ | 9| +-----------------------------------+ -- overlay SELECT overlay('Feathers' PLACING '_' FROM 6); +----------------------------+ |overlay(Feathers, _, 6, -1)| +----------------------------+ | Feathe_ers| +----------------------------+ SELECT overlay('Feathers' PLACING 'ures' FROM 5); +-------------------------------+ |overlay(Feathers, ures, 5, -1)| +-------------------------------+ | Features | +-------------------------------+ -- position SELECT position('bar', 'foobarbar'); +---------------------------+ |position(bar, foobarbar, 1)| +---------------------------+ | 4| +---------------------------+ SELECT position('bar', 'foobarbar', 5); +---------------------------+ |position(bar, foobarbar, 5)| +---------------------------+ | 7| +---------------------------+ SELECT POSITION('bar' IN 'foobarbar'); +-------------------------+ |locate(bar, foobarbar, 1)| +-------------------------+ | 4| +-------------------------+ -- printf SELECT printf("Hello World %d %s", 100, "days"); +------------------------------------+ |printf(Hello World %d %s, 100, days)| +------------------------------------+ | Hello World 100 days| +------------------------------------+ -- regexp_count SELECT regexp_count('Steven Jones and Stephen Smith are the best players', 'Ste(v|ph)en'); +------------------------------------------------------------------------------+ |regexp_count(Steven Jones and Stephen Smith are the best players, Ste(v|ph)en)| +------------------------------------------------------------------------------+ | 2| +------------------------------------------------------------------------------+ SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}'); +--------------------------------------------------+ |regexp_count(abcdefghijklmnopqrstuvwxyz, [a-z]{3})| +--------------------------------------------------+ | 8| +--------------------------------------------------+ -- regexp_extract SELECT regexp_extract('100-200', '(\\d+)-(\\d+)', 1); +---------------------------------------+ |regexp_extract(100-200, (\d+)-(\d+), 1)| +---------------------------------------+ | 100| +---------------------------------------+ -- regexp_extract_all SELECT regexp_extract_all('100-200, 300-400', '(\\d+)-(\\d+)', 1); +----------------------------------------------------+ |regexp_extract_all(100-200, 300-400, (\d+)-(\d+), 1)| +----------------------------------------------------+ | [100, 300]| +----------------------------------------------------+ -- regexp_instr SELECT regexp_instr('user@opensearch.org', '@[^.]*'); +----------------------------------------------+ |regexp_instr(user@opensearch.org, @[^.]*, 0)| +----------------------------------------------+ | 5| +----------------------------------------------+ -- regexp_replace SELECT regexp_replace('100-200', '(\\d+)', 'num'); +--------------------------------------+ |regexp_replace(100-200, (\d+), num, 1)| +--------------------------------------+ | num-num| +--------------------------------------+ -- regexp_substr SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', 'Ste(v|ph)en'); +-------------------------------------------------------------------------------+ |regexp_substr(Steven Jones and Stephen Smith are the best players, Ste(v|ph)en)| +-------------------------------------------------------------------------------+ | Steven| +-------------------------------------------------------------------------------+ SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', 'Jeck'); +------------------------------------------------------------------------+ |regexp_substr(Steven Jones and Stephen Smith are the best players, Jeck)| +------------------------------------------------------------------------+ | NULL| +------------------------------------------------------------------------+ -- repeat SELECT repeat('123', 2); +--------------+ |repeat(123, 2)| +--------------+ | 123123| +--------------+ -- replace SELECT replace('ABCabc', 'abc', 'DEF'); +-------------------------+ |replace(ABCabc, abc, DEF)| +-------------------------+ | ABCDEF| +-------------------------+ -- right SELECT right('Feathers', 3); +-------------------+ |right(Feathers, 3)| +-------------------+ | ers| +-------------------+ -- rpad SELECT rpad('hi', 5, '??'); +---------------+ |rpad(hi, 5, ??)| +---------------+ | hi???| +---------------+ SELECT rpad('hi', 1, '??'); +---------------+ |rpad(hi, 1, ??)| +---------------+ | h| +---------------+ SELECT rpad('hi', 5); +--------------+ |rpad(hi, 5, )| +--------------+ | hi | +--------------+ SELECT hex(rpad(unhex('aabb'), 5)); +--------------------------------+ |hex(rpad(unhex(aabb), 5, X'00'))| +--------------------------------+ | AABB000000| +--------------------------------+ SELECT hex(rpad(unhex('aabb'), 5, unhex('1122'))); +--------------------------------------+ |hex(rpad(unhex(aabb), 5, unhex(1122)))| +--------------------------------------+ | AABB112211| +--------------------------------------+ -- rtrim SELECT rtrim(' Feathers '); +----------------------+ |rtrim( Feathers )| +----------------------+ | Feathers| +----------------------+ -- sentences SELECT sentences('Hi there! Good morning.'); +--------------------------------------+ |sentences(Hi there! Good morning., , )| +--------------------------------------+ | [[Hi, there], [Go...| +--------------------------------------+ -- soundex SELECT soundex('Miller'); +---------------+ |soundex(Miller)| +---------------+ | M460| +---------------+ -- space SELECT concat(space(2), '1'); +-------------------+ |concat(space(2), 1)| +-------------------+ | 1| +-------------------+ -- split SELECT split('oneAtwoBthreeC', '[ABC]'); +--------------------------------+ |split(oneAtwoBthreeC, [ABC], -1)| +--------------------------------+ | [one, two, three, ]| +--------------------------------+ SELECT split('oneAtwoBthreeC', '[ABC]', -1); +--------------------------------+ |split(oneAtwoBthreeC, [ABC], -1)| +--------------------------------+ | [one, two, three, ]| +--------------------------------+ SELECT split('oneAtwoBthreeC', '[ABC]', 2); +-------------------------------+ |split(oneAtwoBthreeC, [ABC], 2)| +-------------------------------+ | [one, twoBthreeC]| +-------------------------------+ -- split_part SELECT split_part('11.12.13', '.', 3); +--------------------------+ |split_part(11.12.13, ., 3)| +--------------------------+ | 13| +--------------------------+ -- startswith SELECT startswith('Feathers', 'Fea'); +----------------------------+ |startswith(Feathers, Fea)| +----------------------------+ | true| +----------------------------+ SELECT startswith('Feathers', 'SQL'); +--------------------------+ |startswith(Feathers, SQL)| +--------------------------+ | false| +--------------------------+ SELECT startswith('Feathers', null); +---------------------------+ |startswith(Feathers, NULL)| +---------------------------+ | NULL| +---------------------------+ SELECT startswith(x'537061726b2053514c', x'537061726b'); +------------------------------------------------+ |startswith(X'537061726B2053514C', X'537061726B')| +------------------------------------------------+ | true| +------------------------------------------------+ SELECT startswith(x'537061726b2053514c', x'53514c'); +--------------------------------------------+ |startswith(X'537061726B2053514C', X'53514C')| +--------------------------------------------+ | false| +--------------------------------------------+ -- substr SELECT substr('Feathers', 5); +--------------------------------+ |substr(Feathers, 5, 2147483647)| +--------------------------------+ | hers | +--------------------------------+ SELECT substr('Feathers', -3); +---------------------------------+ |substr(Feathers, -3, 2147483647)| +---------------------------------+ | ers| +---------------------------------+ SELECT substr('Feathers', 5, 1); +-----------------------+ |substr(Feathers, 5, 1)| +-----------------------+ | h| +-----------------------+ SELECT substr('Feathers' FROM 5); +-----------------------------------+ |substring(Feathers, 5, 2147483647)| +-----------------------------------+ | hers | +-----------------------------------+ SELECT substr('Feathers' FROM -3); +------------------------------------+ |substring(Feathers, -3, 2147483647)| +------------------------------------+ | ers| +------------------------------------+ SELECT substr('Feathers' FROM 5 FOR 1); +--------------------------+ |substring(Feathers, 5, 1)| +--------------------------+ | h| +--------------------------+ -- substring SELECT substring('Feathers', 5); +-----------------------------------+ |substring(Feathers, 5, 2147483647)| +-----------------------------------+ | hers | +-----------------------------------+ SELECT substring('Feathers', -3); +------------------------------------+ |substring(Feathers, -3, 2147483647)| +------------------------------------+ | ers| +------------------------------------+ SELECT substring('Feathers', 5, 1); +--------------------------+ |substring(Feathers, 5, 1)| +--------------------------+ | h| +--------------------------+ SELECT substring('Feathers' FROM 5); +-----------------------------------+ |substring(Feathers, 5, 2147483647)| +-----------------------------------+ | hers | +-----------------------------------+ SELECT substring('Feathers' FROM -3); +------------------------------------+ |substring(Feathers, -3, 2147483647)| +------------------------------------+ | ers| +------------------------------------+ SELECT substring('Feathers' FROM 5 FOR 1); +--------------------------+ |substring(Feathers, 5, 1)| +--------------------------+ | h| +--------------------------+ -- substring_index SELECT substring_index('www.apache.org', '.', 2); +-------------------------------------+ |substring_index(www.apache.org, ., 2)| +-------------------------------------+ | www.apache| +-------------------------------------+ -- to_binary SELECT to_binary('abc', 'utf-8'); +---------------------+ |to_binary(abc, utf-8)| +---------------------+ | [61 62 63]| +---------------------+ -- to_char SELECT to_char(454, '999'); +-----------------+ |to_char(454, 999)| +-----------------+ | 454| +-----------------+ SELECT to_char(454.00, '000D00'); +-----------------------+ |to_char(454.00, 000D00)| +-----------------------+ | 454.00| +-----------------------+ SELECT to_char(12454, '99G999'); +----------------------+ |to_char(12454, 99G999)| +----------------------+ | 12,454| +----------------------+ SELECT to_char(78.12, '$99.99'); +----------------------+ |to_char(78.12, $99.99)| +----------------------+ | $78.12| +----------------------+ SELECT to_char(-12454.8, '99G999D9S'); +----------------------------+ |to_char(-12454.8, 99G999D9S)| +----------------------------+ | 12,454.8-| +----------------------------+ -- to_number SELECT to_number('454', '999'); +-------------------+ |to_number(454, 999)| +-------------------+ | 454| +-------------------+ SELECT to_number('454.00', '000.00'); +-------------------------+ |to_number(454.00, 000.00)| +-------------------------+ | 454.00| +-------------------------+ SELECT to_number('12,454', '99,999'); +-------------------------+ |to_number(12,454, 99,999)| +-------------------------+ | 12454| +-------------------------+ SELECT to_number('$78.12', '$99.99'); +-------------------------+ |to_number($78.12, $99.99)| +-------------------------+ | 78.12| +-------------------------+ SELECT to_number('12,454.8-', '99,999.9S'); +-------------------------------+ |to_number(12,454.8-, 99,999.9S)| +-------------------------------+ | -12454.8| +-------------------------------+ -- to_varchar SELECT to_varchar(454, '999'); +-----------------+ |to_char(454, 999)| +-----------------+ | 454| +-----------------+ SELECT to_varchar(454.00, '000D00'); +-----------------------+ |to_char(454.00, 000D00)| +-----------------------+ | 454.00| +-----------------------+ SELECT to_varchar(12454, '99G999'); +----------------------+ |to_char(12454, 99G999)| +----------------------+ | 12,454| +----------------------+ SELECT to_varchar(78.12, '$99.99'); +----------------------+ |to_char(78.12, $99.99)| +----------------------+ | $78.12| +----------------------+ SELECT to_varchar(-12454.8, '99G999D9S'); +----------------------------+ |to_char(-12454.8, 99G999D9S)| +----------------------------+ | 12,454.8-| +----------------------------+ -- translate SELECT translate('AaBbCc', 'abc', '123'); +---------------------------+ |translate(AaBbCc, abc, 123)| +---------------------------+ | A1B2C3| +---------------------------+ -- try_to_binary SELECT try_to_binary('abc', 'utf-8'); +-------------------------+ |try_to_binary(abc, utf-8)| +-------------------------+ | [61 62 63]| +-------------------------+ select try_to_binary('a!', 'base64'); +-------------------------+ |try_to_binary(a!, base64)| +-------------------------+ | NULL| +-------------------------+ select try_to_binary('abc', 'invalidFormat'); +---------------------------------+ |try_to_binary(abc, invalidFormat)| +---------------------------------+ | NULL| +---------------------------------+ -- try_to_number SELECT try_to_number('454', '999'); +-----------------------+ |try_to_number(454, 999)| +-----------------------+ | 454| +-----------------------+ SELECT try_to_number('454.00', '000.00'); +-----------------------------+ |try_to_number(454.00, 000.00)| +-----------------------------+ | 454.00| +-----------------------------+ SELECT try_to_number('12,454', '99,999'); +-----------------------------+ |try_to_number(12,454, 99,999)| +-----------------------------+ | 12454| +-----------------------------+ SELECT try_to_number('$78.12', '$99.99'); +-----------------------------+ |try_to_number($78.12, $99.99)| +-----------------------------+ | 78.12| +-----------------------------+ SELECT try_to_number('12,454.8-', '99,999.9S'); +-----------------------------------+ |try_to_number(12,454.8-, 99,999.9S)| +-----------------------------------+ | -12454.8| +-----------------------------------+ -- ucase SELECT ucase('Feathers'); +---------------+ |ucase(Feathers)| +---------------+ | FEATHERS| +---------------+ -- unbase64 SELECT unbase64('U3BhcmsgU1FM'); +----------------------+ |unbase64(U3BhcmsgU1FM)| +----------------------+ | [53 70 61 72 6B 2...| +----------------------+ -- upper SELECT upper('Feathers'); +---------------+ |upper(Feathers)| +---------------+ | FEATHERS| +---------------+ ``` #### Funzioni di data e ora **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) **** | Funzione | Description | | --- | --- | | add\$1months (data\$1iniziale, num\$1months) | Restituisce la data successiva. num\$1months start\$1date | | convert\$1timezone ([SourceTz,] targetTZ, SourceTs) | Converte il timestamp senza fuso orario dal fuso orario a. sourceTs sourceTz targetTz | | curdata () | Restituisce la data corrente all'inizio della valutazione della query. Tutte le chiamate di curdate all'interno della stessa query restituiscono lo stesso valore. | | current\$1date () | Restituisce la data corrente all'inizio della valutazione della query. Tutte le chiamate di current\$1date all'interno della stessa query restituiscono lo stesso valore. | | data\$1corrente | Restituisce la data corrente all'inizio della valutazione della query. | | current\$1timestamp () | Restituisce il timestamp corrente all'inizio della valutazione della query. Tutte le chiamate di current\$1timestamp all'interno della stessa query restituiscono lo stesso valore. | | current\$1timestamp | Restituisce il timestamp corrente all'inizio della valutazione della query. | | current\$1timezone () | Restituisce il fuso orario locale della sessione corrente. | | date\$1add (data\$1iniziale, num\$1giorni) | Restituisce la data successiva. num\$1days start\$1date | | date\$1diff (DataFine, DataInizio) | Restituisce il numero di giorni compreso tra a. startDate endDate | | date\$1format (timestamp, fmt) | Converte in un valore timestamp di stringa nel formato specificato dal formato della data. fmt | | date\$1from\$1unix\$1date (giorni) | Crea la data a partire dal numero di giorni dal 01/01/1970. | | date\$1part (campo, fonte) | Estrae una parte della sorgente o dell' date/timestamp intervallo. | | date\$1sub (data\$1iniziale, num\$1giorni) | Restituisce la data precedentenum\$1days. start\$1date | | date\$1trunc (fmt, ts) | Restituisce il timestamp ts troncato all'unità specificata dal modello di formato. fmt | | dateadd (data\$1iniziale, num\$1days) | Restituisce la data successiva. num\$1days start\$1date | | datediff (DataFine, DataAvvio) | Restituisce il numero di giorni da a. startDate endDate | | datepart (campo, fonte) | Estrae una parte della sorgente date/timestamp o dell'intervallo. | | giorno (data) | Restituisce il giorno del mese della data/ora. | | giornodel mese (data) | Restituisce il giorno del mese della data/ora. | | giornodella settimana (data) | Restituisce il giorno della settimana per date/timestamp (1 = domenica, 2 = lunedì,..., 7 = sabato). | | giornodel'anno (data) | Restituisce il giorno dell'anno della data/ora. | | estratto (campo DALLA fonte) | Estrae una parte della sorgente date/timestamp o dell'intervallo. | | from\$1unixtime (unix\$1time [, fmt]) | unix\$1timeRestituisce nel formato fmt specificato. | | from\$1utc\$1timestamp (timestamp, fuso orario) | Dato un timestamp come '2017-07-14 02:40:00.0 ', lo interpreta come un orario in UTC e visualizza quell'ora come un timestamp nel fuso orario specificato. Ad esempio, 'GMT\$11' restituirebbe '2017-07-14 03:40:00.0 '. | | ora (timestamp) | Restituisce il componente orario della stringa/timestamp. | | last\$1day (data) | Restituisce l'ultimo giorno del mese a cui appartiene la data. | | timestamp locale () | Restituisce il timestamp corrente senza fuso orario all'inizio della valutazione della query. Tutte le chiamate di localtimestamp all'interno della stessa query restituiscono lo stesso valore. | | timestamp locale | Restituisce la data-ora locale corrente nel fuso orario della sessione all'inizio della valutazione della query. | | make\$1date (anno, mese, giorno) | Crea data dai campi relativi all'anno, al mese e al giorno. | | make\$1dt\$1interval ([giorni [, ore [, minuti [, secondi]]]]) | Calcola la DayTimeIntervalType durata in giorni, ore, minuti e secondi. | | make\$1interval ([anni [, mesi [, settimane [, giorni [, ore [, minuti [, secondi]]]]]]]]) | Crea un intervallo tra anni, mesi, settimane, giorni, ore, minuti e secondi. | | make\$1timestamp (anno, mese, giorno, ora, min, sec [, fuso orario]) | Crea timestamp dai campi anno, mese, giorno, ora, min, sec e fuso orario. | | make\$1timestamp\$1ltz (anno, mese, giorno, ora, min, sec [, fuso orario]) | Crea il timestamp corrente con il fuso orario locale utilizzando i campi anno, mese, giorno, ora, min, sec e fuso orario. | | make\$1timestamp\$1ntz (anno, mese, giorno, ora, min, sec) | Crea data-ora locale dai campi anno, mese, giorno, ora, min, sec. | | make\$1ym\$1interval ([anni [, mesi]]) | Crea un intervallo anno-mese tra anni, mesi. | | minuto (timestamp) | Restituisce il componente minuto della stringa/timestamp. | | mese (data) | Restituisce il componente mensile della data/ora. | | months\$1between (timestamp1, timestamp2 [, RoundOff]) | Se è timestamp1 successivo a, timestamp2 allora il risultato è positivo. Se timestamp1 e timestamp2 sono nello stesso giorno del mese, o entrambi sono l'ultimo giorno del mese, l'ora del giorno verrà ignorata. Altrimenti, la differenza viene calcolata in base a 31 giorni al mese e arrotondata a 8 cifre, a meno che RoundOff=False. | | giorno\$1successivo (data\$1inizio, giorno\$1della settimana) | Restituisce la prima data successiva e denominata come indicato. start\$1date La funzione restituisce NULL se almeno uno dei parametri di input è NULL. | | adesso () | Restituisce il timestamp corrente all'inizio della valutazione della query. | | trimestre (data) | Restituisce il trimestre dell'anno per la data, nell'intervallo da 1 a 4. | | secondo (timestamp) | Restituisce il secondo componente della stringa/timestamp. | | finestra\$1sessione (time\$1column, gap\$1duration) | Genera una finestra di sessione con un timestamp che specifica la durata della colonna e del gap. Vedi «Tipi di finestre temporali» nel documento della guida Structured Streaming per spiegazioni dettagliate ed esempi. | | timestamp\$1micros (microsecondi) | Crea un timestamp a partire dal numero di microsecondi dall'epoca UTC. | | timestamp\$1millis (millisecondi) | Crea un timestamp in base al numero di millisecondi trascorsi dall'epoca UTC. | | timestamp\$1seconds (secondi) | Crea il timestamp in base al numero di secondi (può essere frazionario) dall'epoca UTC. | | to\$1date (date\$1str [, fmt]) | Analizza l'espressione con l'date\$1strespressione fino a una data. fmt Restituisce null con un input non valido. Per impostazione predefinita, segue le regole di casting fino a una data se fmt viene omesso. | | to\$1timestamp (timestamp\$1str [, fmt]) | Analizza l'espressione con l'espressione in un timestamp. timestamp\$1str fmt Restituisce null con un input non valido. Per impostazione predefinita, segue le regole di casting in base a un timestamp se viene omesso. fmt | | to\$1timestamp\$1ltz (timestamp\$1str [, fmt]) | Analizza l'espressione con l'espressione in un timestamp con fuso orario locale. timestamp\$1str fmt Restituisce null con un input non valido. Per impostazione predefinita, segue le regole di casting in base a un timestamp se viene omesso. fmt | | to\$1timestamp\$1ntz (timestamp\$1str [, fmt]) | Analizza l'espressione con l'espressione in un timestamp senza fuso orario. timestamp\$1str fmt Restituisce null con un input non valido. Per impostazione predefinita, segue le regole di casting in base a un timestamp se viene omesso. fmt | | to\$1unix\$1timestamp (timeExp [, fmt]) | Restituisce il timestamp UNIX dell'ora specificata. | | to\$1utc\$1timestamp (timestamp, timezone) | Dato un timestamp come '2017-07-14 02:40:00.0 ', lo interpreta come un orario nel fuso orario specificato e visualizza quell'ora come un timestamp in UTC. Ad esempio, 'GMT\$11' restituirebbe '2017-07-14 01:40:00.0 '. | | trunc (data, fmt) | Restituisce date con la parte temporale del giorno troncata all'unità specificata dal modello di formato. fmt | | try\$1to\$1timestamp (timestamp\$1str [, fmt]) | Analizza l'espressione con l'espressione in timestamp\$1str un timestamp. fmt | | unix\$1date (data) | Restituisce il numero di giorni dal 01/01/1970. | | unix\$1micros (timestamp) | Restituisce il numero di microsecondi dal 01/01/1970 00:00:00 UTC. | | unix\$1millis (timestamp) | Restituisce il numero di millisecondi dal 01/01/1970 alle 00:00:00 UTC. Tronca i livelli di precisione più elevati. | | unix\$1seconds (timestamp) | Restituisce il numero di secondi dal 01/01/1970 alle 00:00:00 UTC. Tronca i livelli di precisione più elevati. | | unix\$1timestamp ([timeExp [, fmt]]) | Restituisce il timestamp UNIX dell'ora corrente o specificata. | | giorno della settimana (data) | Restituisce il giorno della settimana per date/timestamp (0 = lunedì, 1 = martedì,..., 6 = domenica). | | settimana dell'anno (data) | Restituisce la settimana dell'anno della data specificata. Si considera che una settimana inizi di lunedì e la settimana 1 è la prima settimana con più di 3 giorni. | | finestra (time\$1column, window\$1duration [, slide\$1duration [, start\$1time]]) | Suddividi le righe in una o più finestre temporali con un timestamp che specifica una colonna. Gli inizi delle finestre sono inclusi ma le estremità delle finestre sono esclusive, ad esempio 12:05 sarà nella finestra [12:05,12:10) ma non in [12:00,12:05). Windows può supportare la precisione in microsecondi. Windows nell'ordine dei mesi non è supportato. Vedi «Window Operations on Event Time» nel documento della guida Structured Streaming per spiegazioni dettagliate ed esempi. | | window\$1time (window\$1column) | Estrai il valore time/session temporale dalla colonna della finestra che può essere utilizzata per il valore temporale dell'evento della finestra. L'ora estratta è (window.end - 1) e riflette il fatto che le finestre di aggregazione hanno un limite superiore esclusivo - [start, end) Vedi 'Window Operations on Event Time' nel documento guida Structured Streaming per spiegazioni dettagliate ed esempi. | | anno (data) | Restituisce il componente annuale del data/timestamp. | **Esempi** ``` -- add_months SELECT add_months('2016-08-31', 1); +-------------------------+ |add_months(2016-08-31, 1)| +-------------------------+ | 2016-09-30| +-------------------------+ -- convert_timezone SELECT convert_timezone('Europe/Brussels', 'America/Los_Angeles', timestamp_ntz'2021-12-06 00:00:00'); +-------------------------------------------------------------------------------------------+ |convert_timezone(Europe/Brussels, America/Los_Angeles, TIMESTAMP_NTZ '2021-12-06 00:00:00')| +-------------------------------------------------------------------------------------------+ | 2021-12-05 15:00:00| +-------------------------------------------------------------------------------------------+ SELECT convert_timezone('Europe/Brussels', timestamp_ntz'2021-12-05 15:00:00'); +------------------------------------------------------------------------------------------+ |convert_timezone(current_timezone(), Europe/Brussels, TIMESTAMP_NTZ '2021-12-05 15:00:00')| +------------------------------------------------------------------------------------------+ | 2021-12-05 07:00:00| +------------------------------------------------------------------------------------------+ -- curdate SELECT curdate(); +--------------+ |current_date()| +--------------+ | 2024-02-24| +--------------+ -- current_date SELECT current_date(); +--------------+ |current_date()| +--------------+ | 2024-02-24| +--------------+ SELECT current_date; +--------------+ |current_date()| +--------------+ | 2024-02-24| +--------------+ -- current_timestamp SELECT current_timestamp(); +--------------------+ | current_timestamp()| +--------------------+ |2024-02-24 16:36:...| +--------------------+ SELECT current_timestamp; +--------------------+ | current_timestamp()| +--------------------+ |2024-02-24 16:36:...| +--------------------+ -- current_timezone SELECT current_timezone(); +------------------+ |current_timezone()| +------------------+ | Asia/Seoul| +------------------+ -- date_add SELECT date_add('2016-07-30', 1); +-----------------------+ |date_add(2016-07-30, 1)| +-----------------------+ | 2016-07-31| +-----------------------+ -- date_diff SELECT date_diff('2009-07-31', '2009-07-30'); +---------------------------------+ |date_diff(2009-07-31, 2009-07-30)| +---------------------------------+ | 1| +---------------------------------+ SELECT date_diff('2009-07-30', '2009-07-31'); +---------------------------------+ |date_diff(2009-07-30, 2009-07-31)| +---------------------------------+ | -1| +---------------------------------+ -- date_format SELECT date_format('2016-04-08', 'y'); +--------------------------+ |date_format(2016-04-08, y)| +--------------------------+ | 2016| +--------------------------+ -- date_from_unix_date SELECT date_from_unix_date(1); +----------------------+ |date_from_unix_date(1)| +----------------------+ | 1970-01-02| +----------------------+ -- date_part SELECT date_part('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456'); +-------------------------------------------------------+ |date_part(YEAR, TIMESTAMP '2019-08-12 01:00:00.123456')| +-------------------------------------------------------+ | 2019| +-------------------------------------------------------+ SELECT date_part('week', timestamp'2019-08-12 01:00:00.123456'); +-------------------------------------------------------+ |date_part(week, TIMESTAMP '2019-08-12 01:00:00.123456')| +-------------------------------------------------------+ | 33| +-------------------------------------------------------+ SELECT date_part('doy', DATE'2019-08-12'); +---------------------------------+ |date_part(doy, DATE '2019-08-12')| +---------------------------------+ | 224| +---------------------------------+ SELECT date_part('SECONDS', timestamp'2019-10-01 00:00:01.000001'); +----------------------------------------------------------+ |date_part(SECONDS, TIMESTAMP '2019-10-01 00:00:01.000001')| +----------------------------------------------------------+ | 1.000001| +----------------------------------------------------------+ SELECT date_part('days', interval 5 days 3 hours 7 minutes); +-------------------------------------------------+ |date_part(days, INTERVAL '5 03:07' DAY TO MINUTE)| +-------------------------------------------------+ | 5| +-------------------------------------------------+ SELECT date_part('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds); +-------------------------------------------------------------+ |date_part(seconds, INTERVAL '05:00:30.001001' HOUR TO SECOND)| +-------------------------------------------------------------+ | 30.001001| +-------------------------------------------------------------+ SELECT date_part('MONTH', INTERVAL '2021-11' YEAR TO MONTH); +--------------------------------------------------+ |date_part(MONTH, INTERVAL '2021-11' YEAR TO MONTH)| +--------------------------------------------------+ | 11| +--------------------------------------------------+ SELECT date_part('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND); +---------------------------------------------------------------+ |date_part(MINUTE, INTERVAL '123 23:55:59.002001' DAY TO SECOND)| +---------------------------------------------------------------+ | 55| +---------------------------------------------------------------+ -- date_sub SELECT date_sub('2016-07-30', 1); +-----------------------+ |date_sub(2016-07-30, 1)| +-----------------------+ | 2016-07-29| +-----------------------+ -- date_trunc SELECT date_trunc('YEAR', '2015-03-05T09:32:05.359'); +-----------------------------------------+ |date_trunc(YEAR, 2015-03-05T09:32:05.359)| +-----------------------------------------+ | 2015-01-01 00:00:00| +-----------------------------------------+ SELECT date_trunc('MM', '2015-03-05T09:32:05.359'); +---------------------------------------+ |date_trunc(MM, 2015-03-05T09:32:05.359)| +---------------------------------------+ | 2015-03-01 00:00:00| +---------------------------------------+ SELECT date_trunc('DD', '2015-03-05T09:32:05.359'); +---------------------------------------+ |date_trunc(DD, 2015-03-05T09:32:05.359)| +---------------------------------------+ | 2015-03-05 00:00:00| +---------------------------------------+ SELECT date_trunc('HOUR', '2015-03-05T09:32:05.359'); +-----------------------------------------+ |date_trunc(HOUR, 2015-03-05T09:32:05.359)| +-----------------------------------------+ | 2015-03-05 09:00:00| +-----------------------------------------+ SELECT date_trunc('MILLISECOND', '2015-03-05T09:32:05.123456'); +---------------------------------------------------+ |date_trunc(MILLISECOND, 2015-03-05T09:32:05.123456)| +---------------------------------------------------+ | 2015-03-05 09:32:...| +---------------------------------------------------+ -- dateadd SELECT dateadd('2016-07-30', 1); +-----------------------+ |date_add(2016-07-30, 1)| +-----------------------+ | 2016-07-31| +-----------------------+ -- datediff SELECT datediff('2009-07-31', '2009-07-30'); +--------------------------------+ |datediff(2009-07-31, 2009-07-30)| +--------------------------------+ | 1| +--------------------------------+ SELECT datediff('2009-07-30', '2009-07-31'); +--------------------------------+ |datediff(2009-07-30, 2009-07-31)| +--------------------------------+ | -1| +--------------------------------+ -- datepart SELECT datepart('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456'); +----------------------------------------------------------+ |datepart(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456')| +----------------------------------------------------------+ | 2019| +----------------------------------------------------------+ SELECT datepart('week', timestamp'2019-08-12 01:00:00.123456'); +----------------------------------------------------------+ |datepart(week FROM TIMESTAMP '2019-08-12 01:00:00.123456')| +----------------------------------------------------------+ | 33| +----------------------------------------------------------+ SELECT datepart('doy', DATE'2019-08-12'); +------------------------------------+ |datepart(doy FROM DATE '2019-08-12')| +------------------------------------+ | 224| +------------------------------------+ SELECT datepart('SECONDS', timestamp'2019-10-01 00:00:01.000001'); +-------------------------------------------------------------+ |datepart(SECONDS FROM TIMESTAMP '2019-10-01 00:00:01.000001')| +-------------------------------------------------------------+ | 1.000001| +-------------------------------------------------------------+ SELECT datepart('days', interval 5 days 3 hours 7 minutes); +----------------------------------------------------+ |datepart(days FROM INTERVAL '5 03:07' DAY TO MINUTE)| +----------------------------------------------------+ | 5| +----------------------------------------------------+ SELECT datepart('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds); +----------------------------------------------------------------+ |datepart(seconds FROM INTERVAL '05:00:30.001001' HOUR TO SECOND)| +----------------------------------------------------------------+ | 30.001001| +----------------------------------------------------------------+ SELECT datepart('MONTH', INTERVAL '2021-11' YEAR TO MONTH); +-----------------------------------------------------+ |datepart(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH)| +-----------------------------------------------------+ | 11| +-----------------------------------------------------+ SELECT datepart('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND); +------------------------------------------------------------------+ |datepart(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND)| +------------------------------------------------------------------+ | 55| +------------------------------------------------------------------+ -- day SELECT day('2009-07-30'); +---------------+ |day(2009-07-30)| +---------------+ | 30| +---------------+ -- dayofmonth SELECT dayofmonth('2009-07-30'); +----------------------+ |dayofmonth(2009-07-30)| +----------------------+ | 30| +----------------------+ -- dayofweek SELECT dayofweek('2009-07-30'); +---------------------+ |dayofweek(2009-07-30)| +---------------------+ | 5| +---------------------+ -- dayofyear SELECT dayofyear('2016-04-09'); +---------------------+ |dayofyear(2016-04-09)| +---------------------+ | 100| +---------------------+ -- extract SELECT extract(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456'); +---------------------------------------------------------+ |extract(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456')| +---------------------------------------------------------+ | 2019| +---------------------------------------------------------+ SELECT extract(week FROM timestamp'2019-08-12 01:00:00.123456'); +---------------------------------------------------------+ |extract(week FROM TIMESTAMP '2019-08-12 01:00:00.123456')| +---------------------------------------------------------+ | 33| +---------------------------------------------------------+ SELECT extract(doy FROM DATE'2019-08-12'); +-----------------------------------+ |extract(doy FROM DATE '2019-08-12')| +-----------------------------------+ | 224| +-----------------------------------+ SELECT extract(SECONDS FROM timestamp'2019-10-01 00:00:01.000001'); +------------------------------------------------------------+ |extract(SECONDS FROM TIMESTAMP '2019-10-01 00:00:01.000001')| +------------------------------------------------------------+ | 1.000001| +------------------------------------------------------------+ SELECT extract(days FROM interval 5 days 3 hours 7 minutes); +---------------------------------------------------+ |extract(days FROM INTERVAL '5 03:07' DAY TO MINUTE)| +---------------------------------------------------+ | 5| +---------------------------------------------------+ SELECT extract(seconds FROM interval 5 hours 30 seconds 1 milliseconds 1 microseconds); +---------------------------------------------------------------+ |extract(seconds FROM INTERVAL '05:00:30.001001' HOUR TO SECOND)| +---------------------------------------------------------------+ | 30.001001| +---------------------------------------------------------------+ SELECT extract(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH); +----------------------------------------------------+ |extract(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH)| +----------------------------------------------------+ | 11| +----------------------------------------------------+ SELECT extract(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND); +-----------------------------------------------------------------+ |extract(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND)| +-----------------------------------------------------------------+ | 55| +-----------------------------------------------------------------+ -- from_unixtime SELECT from_unixtime(0, 'yyyy-MM-dd HH:mm:ss'); +-------------------------------------+ |from_unixtime(0, yyyy-MM-dd HH:mm:ss)| +-------------------------------------+ | 1970-01-01 09:00:00| +-------------------------------------+ SELECT from_unixtime(0); +-------------------------------------+ |from_unixtime(0, yyyy-MM-dd HH:mm:ss)| +-------------------------------------+ | 1970-01-01 09:00:00| +-------------------------------------+ -- from_utc_timestamp SELECT from_utc_timestamp('2016-08-31', 'Asia/Seoul'); +------------------------------------------+ |from_utc_timestamp(2016-08-31, Asia/Seoul)| +------------------------------------------+ | 2016-08-31 09:00:00| +------------------------------------------+ -- hour SELECT hour('2009-07-30 12:58:59'); +-------------------------+ |hour(2009-07-30 12:58:59)| +-------------------------+ | 12| +-------------------------+ -- last_day SELECT last_day('2009-01-12'); +--------------------+ |last_day(2009-01-12)| +--------------------+ | 2009-01-31| +--------------------+ -- localtimestamp SELECT localtimestamp(); +--------------------+ | localtimestamp()| +--------------------+ |2024-02-24 16:36:...| +--------------------+ -- make_date SELECT make_date(2013, 7, 15); +----------------------+ |make_date(2013, 7, 15)| +----------------------+ | 2013-07-15| +----------------------+ SELECT make_date(2019, 7, NULL); +------------------------+ |make_date(2019, 7, NULL)| +------------------------+ | NULL| +------------------------+ -- make_dt_interval SELECT make_dt_interval(1, 12, 30, 01.001001); +-------------------------------------+ |make_dt_interval(1, 12, 30, 1.001001)| +-------------------------------------+ | INTERVAL '1 12:30...| +-------------------------------------+ SELECT make_dt_interval(2); +-----------------------------------+ |make_dt_interval(2, 0, 0, 0.000000)| +-----------------------------------+ | INTERVAL '2 00:00...| +-----------------------------------+ SELECT make_dt_interval(100, null, 3); +----------------------------------------+ |make_dt_interval(100, NULL, 3, 0.000000)| +----------------------------------------+ | NULL| +----------------------------------------+ -- make_interval SELECT make_interval(100, 11, 1, 1, 12, 30, 01.001001); +----------------------------------------------+ |make_interval(100, 11, 1, 1, 12, 30, 1.001001)| +----------------------------------------------+ | 100 years 11 mont...| +----------------------------------------------+ SELECT make_interval(100, null, 3); +----------------------------------------------+ |make_interval(100, NULL, 3, 0, 0, 0, 0.000000)| +----------------------------------------------+ | NULL| +----------------------------------------------+ SELECT make_interval(0, 1, 0, 1, 0, 0, 100.000001); +-------------------------------------------+ |make_interval(0, 1, 0, 1, 0, 0, 100.000001)| +-------------------------------------------+ | 1 months 1 days 1...| +-------------------------------------------+ -- make_timestamp SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887); +-------------------------------------------+ |make_timestamp(2014, 12, 28, 6, 30, 45.887)| +-------------------------------------------+ | 2014-12-28 06:30:...| +-------------------------------------------+ SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887, 'CET'); +------------------------------------------------+ |make_timestamp(2014, 12, 28, 6, 30, 45.887, CET)| +------------------------------------------------+ | 2014-12-28 14:30:...| +------------------------------------------------+ SELECT make_timestamp(2019, 6, 30, 23, 59, 60); +---------------------------------------+ |make_timestamp(2019, 6, 30, 23, 59, 60)| +---------------------------------------+ | 2019-07-01 00:00:00| +---------------------------------------+ SELECT make_timestamp(2019, 6, 30, 23, 59, 1); +--------------------------------------+ |make_timestamp(2019, 6, 30, 23, 59, 1)| +--------------------------------------+ | 2019-06-30 23:59:01| +--------------------------------------+ SELECT make_timestamp(null, 7, 22, 15, 30, 0); +--------------------------------------+ |make_timestamp(NULL, 7, 22, 15, 30, 0)| +--------------------------------------+ | NULL| +--------------------------------------+ -- make_timestamp_ltz SELECT make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887); +-----------------------------------------------+ |make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887)| +-----------------------------------------------+ | 2014-12-28 06:30:...| +-----------------------------------------------+ SELECT make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887, 'CET'); +----------------------------------------------------+ |make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887, CET)| +----------------------------------------------------+ | 2014-12-28 14:30:...| +----------------------------------------------------+ SELECT make_timestamp_ltz(2019, 6, 30, 23, 59, 60); +-------------------------------------------+ |make_timestamp_ltz(2019, 6, 30, 23, 59, 60)| +-------------------------------------------+ | 2019-07-01 00:00:00| +-------------------------------------------+ SELECT make_timestamp_ltz(null, 7, 22, 15, 30, 0); +------------------------------------------+ |make_timestamp_ltz(NULL, 7, 22, 15, 30, 0)| +------------------------------------------+ | NULL| +------------------------------------------+ -- make_timestamp_ntz SELECT make_timestamp_ntz(2014, 12, 28, 6, 30, 45.887); +-----------------------------------------------+ |make_timestamp_ntz(2014, 12, 28, 6, 30, 45.887)| +-----------------------------------------------+ | 2014-12-28 06:30:...| +-----------------------------------------------+ SELECT make_timestamp_ntz(2019, 6, 30, 23, 59, 60); +-------------------------------------------+ |make_timestamp_ntz(2019, 6, 30, 23, 59, 60)| +-------------------------------------------+ | 2019-07-01 00:00:00| +-------------------------------------------+ SELECT make_timestamp_ntz(null, 7, 22, 15, 30, 0); +------------------------------------------+ |make_timestamp_ntz(NULL, 7, 22, 15, 30, 0)| +------------------------------------------+ | NULL| +------------------------------------------+ -- make_ym_interval SELECT make_ym_interval(1, 2); +----------------------+ |make_ym_interval(1, 2)| +----------------------+ | INTERVAL '1-2' YE...| +----------------------+ SELECT make_ym_interval(1, 0); +----------------------+ |make_ym_interval(1, 0)| +----------------------+ | INTERVAL '1-0' YE...| +----------------------+ SELECT make_ym_interval(-1, 1); +-----------------------+ |make_ym_interval(-1, 1)| +-----------------------+ | INTERVAL '-0-11' ...| +-----------------------+ SELECT make_ym_interval(2); +----------------------+ |make_ym_interval(2, 0)| +----------------------+ | INTERVAL '2-0' YE...| +----------------------+ -- minute SELECT minute('2009-07-30 12:58:59'); +---------------------------+ |minute(2009-07-30 12:58:59)| +---------------------------+ | 58| +---------------------------+ -- month SELECT month('2016-07-30'); +-----------------+ |month(2016-07-30)| +-----------------+ | 7| +-----------------+ -- months_between SELECT months_between('1997-02-28 10:30:00', '1996-10-30'); +-----------------------------------------------------+ |months_between(1997-02-28 10:30:00, 1996-10-30, true)| +-----------------------------------------------------+ | 3.94959677| +-----------------------------------------------------+ SELECT months_between('1997-02-28 10:30:00', '1996-10-30', false); +------------------------------------------------------+ |months_between(1997-02-28 10:30:00, 1996-10-30, false)| +------------------------------------------------------+ | 3.9495967741935485| +------------------------------------------------------+ -- next_day SELECT next_day('2015-01-14', 'TU'); +------------------------+ |next_day(2015-01-14, TU)| +------------------------+ | 2015-01-20| +------------------------+ -- now SELECT now(); +--------------------+ | now()| +--------------------+ |2024-02-24 16:36:...| +--------------------+ -- quarter SELECT quarter('2016-08-31'); +-------------------+ |quarter(2016-08-31)| +-------------------+ | 3| +-------------------+ -- second SELECT second('2009-07-30 12:58:59'); +---------------------------+ |second(2009-07-30 12:58:59)| +---------------------------+ | 59| +---------------------------+ -- session_window SELECT a, session_window.start, session_window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:10:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, session_window(b, '5 minutes') ORDER BY a, start; +---+-------------------+-------------------+---+ | a| start| end|cnt| +---+-------------------+-------------------+---+ | A1|2021-01-01 00:00:00|2021-01-01 00:09:30| 2| | A1|2021-01-01 00:10:00|2021-01-01 00:15:00| 1| | A2|2021-01-01 00:01:00|2021-01-01 00:06:00| 1| +---+-------------------+-------------------+---+ SELECT a, session_window.start, session_window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:10:00'), ('A2', '2021-01-01 00:01:00'), ('A2', '2021-01-01 00:04:30') AS tab(a, b) GROUP by a, session_window(b, CASE WHEN a = 'A1' THEN '5 minutes' WHEN a = 'A2' THEN '1 minute' ELSE '10 minutes' END) ORDER BY a, start; +---+-------------------+-------------------+---+ | a| start| end|cnt| +---+-------------------+-------------------+---+ | A1|2021-01-01 00:00:00|2021-01-01 00:09:30| 2| | A1|2021-01-01 00:10:00|2021-01-01 00:15:00| 1| | A2|2021-01-01 00:01:00|2021-01-01 00:02:00| 1| | A2|2021-01-01 00:04:30|2021-01-01 00:05:30| 1| +---+-------------------+-------------------+---+ -- timestamp_micros SELECT timestamp_micros(1230219000123123); +----------------------------------+ |timestamp_micros(1230219000123123)| +----------------------------------+ | 2008-12-26 00:30:...| +----------------------------------+ -- timestamp_millis SELECT timestamp_millis(1230219000123); +-------------------------------+ |timestamp_millis(1230219000123)| +-------------------------------+ | 2008-12-26 00:30:...| +-------------------------------+ -- timestamp_seconds SELECT timestamp_seconds(1230219000); +-----------------------------+ |timestamp_seconds(1230219000)| +-----------------------------+ | 2008-12-26 00:30:00| +-----------------------------+ SELECT timestamp_seconds(1230219000.123); +---------------------------------+ |timestamp_seconds(1230219000.123)| +---------------------------------+ | 2008-12-26 00:30:...| +---------------------------------+ -- to_date SELECT to_date('2009-07-30 04:17:52'); +----------------------------+ |to_date(2009-07-30 04:17:52)| +----------------------------+ | 2009-07-30| +----------------------------+ SELECT to_date('2016-12-31', 'yyyy-MM-dd'); +-------------------------------+ |to_date(2016-12-31, yyyy-MM-dd)| +-------------------------------+ | 2016-12-31| +-------------------------------+ -- to_timestamp SELECT to_timestamp('2016-12-31 00:12:00'); +---------------------------------+ |to_timestamp(2016-12-31 00:12:00)| +---------------------------------+ | 2016-12-31 00:12:00| +---------------------------------+ SELECT to_timestamp('2016-12-31', 'yyyy-MM-dd'); +------------------------------------+ |to_timestamp(2016-12-31, yyyy-MM-dd)| +------------------------------------+ | 2016-12-31 00:00:00| +------------------------------------+ -- to_timestamp_ltz SELECT to_timestamp_ltz('2016-12-31 00:12:00'); +-------------------------------------+ |to_timestamp_ltz(2016-12-31 00:12:00)| +-------------------------------------+ | 2016-12-31 00:12:00| +-------------------------------------+ SELECT to_timestamp_ltz('2016-12-31', 'yyyy-MM-dd'); +----------------------------------------+ |to_timestamp_ltz(2016-12-31, yyyy-MM-dd)| +----------------------------------------+ | 2016-12-31 00:00:00| +----------------------------------------+ -- to_timestamp_ntz SELECT to_timestamp_ntz('2016-12-31 00:12:00'); +-------------------------------------+ |to_timestamp_ntz(2016-12-31 00:12:00)| +-------------------------------------+ | 2016-12-31 00:12:00| +-------------------------------------+ SELECT to_timestamp_ntz('2016-12-31', 'yyyy-MM-dd'); +----------------------------------------+ |to_timestamp_ntz(2016-12-31, yyyy-MM-dd)| +----------------------------------------+ | 2016-12-31 00:00:00| +----------------------------------------+ -- to_unix_timestamp SELECT to_unix_timestamp('2016-04-08', 'yyyy-MM-dd'); +-----------------------------------------+ |to_unix_timestamp(2016-04-08, yyyy-MM-dd)| +-----------------------------------------+ | 1460041200| +-----------------------------------------+ -- to_utc_timestamp SELECT to_utc_timestamp('2016-08-31', 'Asia/Seoul'); +----------------------------------------+ |to_utc_timestamp(2016-08-31, Asia/Seoul)| +----------------------------------------+ | 2016-08-30 15:00:00| +----------------------------------------+ -- trunc SELECT trunc('2019-08-04', 'week'); +-----------------------+ |trunc(2019-08-04, week)| +-----------------------+ | 2019-07-29| +-----------------------+ SELECT trunc('2019-08-04', 'quarter'); +--------------------------+ |trunc(2019-08-04, quarter)| +--------------------------+ | 2019-07-01| +--------------------------+ SELECT trunc('2009-02-12', 'MM'); +---------------------+ |trunc(2009-02-12, MM)| +---------------------+ | 2009-02-01| +---------------------+ SELECT trunc('2015-10-27', 'YEAR'); +-----------------------+ |trunc(2015-10-27, YEAR)| +-----------------------+ | 2015-01-01| +-----------------------+ -- try_to_timestamp SELECT try_to_timestamp('2016-12-31 00:12:00'); +-------------------------------------+ |try_to_timestamp(2016-12-31 00:12:00)| +-------------------------------------+ | 2016-12-31 00:12:00| +-------------------------------------+ SELECT try_to_timestamp('2016-12-31', 'yyyy-MM-dd'); +----------------------------------------+ |try_to_timestamp(2016-12-31, yyyy-MM-dd)| +----------------------------------------+ | 2016-12-31 00:00:00| +----------------------------------------+ SELECT try_to_timestamp('foo', 'yyyy-MM-dd'); +---------------------------------+ |try_to_timestamp(foo, yyyy-MM-dd)| +---------------------------------+ | NULL| +---------------------------------+ -- unix_date SELECT unix_date(DATE("1970-01-02")); +---------------------+ |unix_date(1970-01-02)| +---------------------+ | 1| +---------------------+ -- unix_micros SELECT unix_micros(TIMESTAMP('1970-01-01 00:00:01Z')); +---------------------------------+ |unix_micros(1970-01-01 00:00:01Z)| +---------------------------------+ | 1000000| +---------------------------------+ -- unix_millis SELECT unix_millis(TIMESTAMP('1970-01-01 00:00:01Z')); +---------------------------------+ |unix_millis(1970-01-01 00:00:01Z)| +---------------------------------+ | 1000| +---------------------------------+ -- unix_seconds SELECT unix_seconds(TIMESTAMP('1970-01-01 00:00:01Z')); +----------------------------------+ |unix_seconds(1970-01-01 00:00:01Z)| +----------------------------------+ | 1| +----------------------------------+ -- unix_timestamp SELECT unix_timestamp(); +--------------------------------------------------------+ |unix_timestamp(current_timestamp(), yyyy-MM-dd HH:mm:ss)| +--------------------------------------------------------+ | 1708760216| +--------------------------------------------------------+ SELECT unix_timestamp('2016-04-08', 'yyyy-MM-dd'); +--------------------------------------+ |unix_timestamp(2016-04-08, yyyy-MM-dd)| +--------------------------------------+ | 1460041200| +--------------------------------------+ -- weekday SELECT weekday('2009-07-30'); +-------------------+ |weekday(2009-07-30)| +-------------------+ | 3| +-------------------+ -- weekofyear SELECT weekofyear('2008-02-20'); +----------------------+ |weekofyear(2008-02-20)| +----------------------+ | 8| +----------------------+ -- window SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, start; +---+-------------------+-------------------+---+ | a| start| end|cnt| +---+-------------------+-------------------+---+ | A1|2021-01-01 00:00:00|2021-01-01 00:05:00| 2| | A1|2021-01-01 00:05:00|2021-01-01 00:10:00| 1| | A2|2021-01-01 00:00:00|2021-01-01 00:05:00| 1| +---+-------------------+-------------------+---+ SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '10 minutes', '5 minutes') ORDER BY a, start; +---+-------------------+-------------------+---+ | a| start| end|cnt| +---+-------------------+-------------------+---+ | A1|2020-12-31 23:55:00|2021-01-01 00:05:00| 2| | A1|2021-01-01 00:00:00|2021-01-01 00:10:00| 3| | A1|2021-01-01 00:05:00|2021-01-01 00:15:00| 1| | A2|2020-12-31 23:55:00|2021-01-01 00:05:00| 1| | A2|2021-01-01 00:00:00|2021-01-01 00:10:00| 1| +---+-------------------+-------------------+---+ -- window_time SELECT a, window.start as start, window.end as end, window_time(window), cnt FROM (SELECT a, window, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, window.start); +---+-------------------+-------------------+--------------------+---+ | a| start| end| window_time(window)|cnt| +---+-------------------+-------------------+--------------------+---+ | A1|2021-01-01 00:00:00|2021-01-01 00:05:00|2021-01-01 00:04:...| 2| | A1|2021-01-01 00:05:00|2021-01-01 00:10:00|2021-01-01 00:09:...| 1| | A2|2021-01-01 00:00:00|2021-01-01 00:05:00|2021-01-01 00:04:...| 1| +---+-------------------+-------------------+--------------------+---+ -- year SELECT year('2016-07-30'); +----------------+ |year(2016-07-30)| +----------------+ | 2016| +----------------+ ``` #### Funzioni di aggregazione **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, consulta. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) Le funzioni di aggregazione operano sui valori delle righe per eseguire calcoli matematici come somma, media, conteggio, minimum/maximum valori, deviazione standard e stima, oltre ad alcune operazioni non matematiche. **Sintassi** ``` aggregate_function(input1 [, input2, ...]) FILTER (WHERE boolean_expression) ``` **Parametri** + `boolean_expression`- Specifica qualsiasi espressione che restituisce un risultato di tipo booleano. Due o più espressioni possono essere combinate insieme utilizzando gli operatori logici (AND, OR). **Funzioni aggregate ordinate** Queste funzioni di aggregazione utilizzano una sintassi diversa rispetto alle altre funzioni di aggregazione in modo da specificare un'espressione (in genere un nome di colonna) in base alla quale ordinare i valori. **Sintassi** ``` { PERCENTILE_CONT | PERCENTILE_DISC }(percentile) WITHIN GROUP (ORDER BY { order_by_expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] }) FILTER (WHERE boolean_expression) ``` **Parametri** + `percentile`- Il percentile del valore che vuoi trovare. Il percentile deve essere una costante compresa tra 0,0 e 1,0. + `order_by_expression`- L'espressione (in genere il nome di una colonna) in base alla quale ordinare i valori prima di aggregarli. + `boolean_expression`- Speciifica qualsiasi espressione che restituisce un risultato di tipo booleano. Due o più espressioni possono essere combinate insieme utilizzando gli operatori logici (AND, OR). **Esempi** ``` CREATE OR REPLACE TEMPORARY VIEW basic_pays AS SELECT * FROM VALUES ('Jane Doe','Accounting',8435), ('Akua Mansa','Accounting',9998), ('John Doe','Accounting',8992), ('Juan Li','Accounting',8870), ('Carlos Salazar','Accounting',11472), ('Arnav Desai','Accounting',6627), ('Saanvi Sarkar','IT',8113), ('Shirley Rodriguez','IT',5186), ('Nikki Wolf','Sales',9181), ('Alejandro Rosalez','Sales',9441), ('Nikhil Jayashankar','Sales',6660), ('Richard Roe','Sales',10563), ('Pat Candella','SCM',10449), ('Gerard Hernandez','SCM',6949), ('Pamela Castillo','SCM',11303), ('Paulo Santos','SCM',11798), ('Jorge Souza','SCM',10586) AS basic_pays(employee_name, department, salary); SELECT * FROM basic_pays; +-------------------+----------+------+ | employee_name |department|salary| +-------------------+----------+------+ | Arnav Desai |Accounting| 6627| | Jorge Souza | SCM| 10586| | Jane Doe |Accounting| 8435| | Nikhil Jayashankar| Sales| 6660| | Diego Vanauf | Sales| 10563| | Carlos Salazar |Accounting| 11472| | Gerard Hernandez | SCM| 6949| | John Doe |Accounting| 8992| | Nikki Wolf | Sales| 9181| | Paulo Santos | SCM| 11798| | Saanvi Sarkar | IT| 8113| | Shirley Rodriguez | IT| 5186| | Pat Candella | SCM| 10449| | Akua Mansa |Accounting| 9998| | Pamela Castillo | SCM| 11303| | Alejandro Rosalez | Sales| 9441| | Juan Li |Accounting| 8870| +-------------------+----------+------+ SELECT department, percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) AS pc1, percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) FILTER (WHERE employee_name LIKE '%Bo%') AS pc2, percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) AS pc3, percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) FILTER (WHERE employee_name LIKE '%Bo%') AS pc4, percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) AS pd1, percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) FILTER (WHERE employee_name LIKE '%Bo%') AS pd2, percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) AS pd3, percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) FILTER (WHERE employee_name LIKE '%Bo%') AS pd4 FROM basic_pays GROUP BY department ORDER BY department; +----------+-------+--------+-------+--------+-----+-----+-----+-----+ |department| pc1| pc2| pc3| pc4| pd1| pd2| pd3| pd4| +----------+-------+--------+-------+--------+-----+-----+-----+-----+ |Accounting|8543.75| 7838.25| 9746.5|10260.75| 8435| 6627| 9998|11472| | IT|5917.75| NULL|7381.25| NULL| 5186| NULL| 8113| NULL| | Sales|8550.75| NULL| 9721.5| NULL| 6660| NULL|10563| NULL| | SCM|10449.0|10786.25|11303.0|11460.75|10449|10449|11303|11798| +----------+-------+--------+-------+--------+-----+-----+-----+-----+ ``` #### Funzioni condizionali **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi[Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql). **** | Funzione | Description | | --- | --- | | coalesce (espr 1, espr 2,...) | Restituisce il primo argomento non nullo, se esiste. Altrimenti, null. | | se (espr 1, espr 2, espr 3) | Se expr1 restituisce true, restituisce; altrimenti restituisce. expr2 expr3 | | ifnull (espr 1, espr 2) | Restituisce expr2 se expr1 è nullo o meno. expr1 | | nanvl (espr 1, espr 2) | Restituisce expr1 se non è NaN o expr2 altro. | | nullif (espr 1, espr 2) | Restituisce null se è uguale a o meno. expr1 expr2 expr1 | | nvl (espr 1, espr 2) | Restituisce expr2 se expr1 è nullo o meno. expr1 | | nvl2 (espr 1, espr 2, espr 3) | Restituisce se non è nullo o altrimenti. expr2 expr1 expr3 | | CASO IN CUI expr1 POI expr2 [QUANDO expr3 THEN expr4] \$1 [ELSE expr5] END | When expr1 = true, restituisceexpr2; altrimenti quando = true, restituisce; altrimenti ritorna. expr3 expr4 expr5 | **Esempi** ``` -- coalesce SELECT coalesce(NULL, 1, NULL); +-----------------------+ |coalesce(NULL, 1, NULL)| +-----------------------+ | 1| +-----------------------+ -- if SELECT if(1 < 2, 'a', 'b'); +-------------------+ |(IF((1 < 2), a, b))| +-------------------+ | a| +-------------------+ -- ifnull SELECT ifnull(NULL, array('2')); +----------------------+ |ifnull(NULL, array(2))| +----------------------+ | [2]| +----------------------+ -- nanvl SELECT nanvl(cast('NaN' as double), 123); +-------------------------------+ |nanvl(CAST(NaN AS DOUBLE), 123)| +-------------------------------+ | 123.0| +-------------------------------+ -- nullif SELECT nullif(2, 2); +------------+ |nullif(2, 2)| +------------+ | NULL| +------------+ -- nvl SELECT nvl(NULL, array('2')); +-------------------+ |nvl(NULL, array(2))| +-------------------+ | [2]| +-------------------+ -- nvl2 SELECT nvl2(NULL, 2, 1); +----------------+ |nvl2(NULL, 2, 1)| +----------------+ | 1| +----------------+ -- when SELECT CASE WHEN 1 > 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END; +-----------------------------------------------------------+ |CASE WHEN (1 > 0) THEN 1 WHEN (2 > 0) THEN 2.0 ELSE 1.2 END| +-----------------------------------------------------------+ | 1.0| +-----------------------------------------------------------+ SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END; +-----------------------------------------------------------+ |CASE WHEN (1 < 0) THEN 1 WHEN (2 > 0) THEN 2.0 ELSE 1.2 END| +-----------------------------------------------------------+ | 2.0| +-----------------------------------------------------------+ SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 < 0 THEN 2.0 END; +--------------------------------------------------+ |CASE WHEN (1 < 0) THEN 1 WHEN (2 < 0) THEN 2.0 END| +--------------------------------------------------+ | NULL| +--------------------------------------------------+ ``` #### Funzioni JSON **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi[Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql). **** | Funzione | Description | | --- | --- | | from\$1json (JsonStr, schema [, opzioni]) | Restituisce un valore di struttura con i dati `JsonStr` e `schema`. | | get\$1json\$1object (json\$1txt, percorso) | Estrae un oggetto json da `path`. | | json\$1array\$1length (JsonArray) | Restituisce il numero di elementi nell'array JSON più esterno. | | json\$1object\$1keys (json\$1object) | Restituisce tutte le chiavi dell'oggetto JSON più esterno come array. | | json\$1tuple (JsonStr, p1, p2,..., pn) | Restituisce una tupla come la funzione get\$1json\$1object, ma accetta più nomi. Tutti i parametri di input e i tipi di colonne di output sono stringhe. | | schema\$1of\$1json (json [, opzioni]) | Restituisce lo schema nel formato DDL della stringa JSON. | | to\$1json (expr [, opzioni]) | Restituisce una stringa JSON con un determinato valore di struttura | **Esempi** ``` -- from_json SELECT from_json('{"a":1, "b":0.8}', 'a INT, b DOUBLE'); +---------------------------+ | from_json({"a":1, "b":0.8}) | +---------------------------+ | {1, 0.8} | +---------------------------+ SELECT from_json('{"time":"26/08/2015"}', 'time Timestamp', map('timestampFormat', 'dd/MM/yyyy')); +--------------------------------+ | from_json({"time":"26/08/2015"}) | +--------------------------------+ | {2015-08-26 00:00... | +--------------------------------+ SELECT from_json('{"teacher": "Alice", "student": [{"name": "Bob", "rank": 1}, {"name": "Charlie", "rank": 2}]}', 'STRUCT>>'); +--------------------------------------------------------------------------------------------------------+ | from_json({"teacher": "Alice", "student": [{"name": "Bob", "rank": 1}, {"name": "Charlie", "rank": 2}]}) | +--------------------------------------------------------------------------------------------------------+ | {Alice, [{Bob, 1}... | +--------------------------------------------------------------------------------------------------------+ -- get_json_object SELECT get_json_object('{"a":"b"}', '$.a'); +-------------------------------+ | get_json_object({"a":"b"}, $.a) | +-------------------------------+ | b | +-------------------------------+ -- json_array_length SELECT json_array_length('[1,2,3,4]'); +----------------------------+ | json_array_length([1,2,3,4]) | +----------------------------+ | 4 | +----------------------------+ SELECT json_array_length('[1,2,3,{"f1":1,"f2":[5,6]},4]'); +------------------------------------------------+ | json_array_length([1,2,3,{"f1":1,"f2":[5,6]},4]) | +------------------------------------------------+ | 5 | +------------------------------------------------+ SELECT json_array_length('[1,2'); +-----------------------+ | json_array_length([1,2) | +-----------------------+ | NULL | +-----------------------+ -- json_object_keys SELECT json_object_keys('{}'); +--------------------+ | json_object_keys({}) | +--------------------+ | [] | +--------------------+ SELECT json_object_keys('{"key": "value"}'); +----------------------------------+ | json_object_keys({"key": "value"}) | +----------------------------------+ | [key] | +----------------------------------+ SELECT json_object_keys('{"f1":"abc","f2":{"f3":"a", "f4":"b"}}'); +--------------------------------------------------------+ | json_object_keys({"f1":"abc","f2":{"f3":"a", "f4":"b"}}) | +--------------------------------------------------------+ | [f1, f2] | +--------------------------------------------------------+ -- json_tuple SELECT json_tuple('{"a":1, "b":2}', 'a', 'b'); +---+---+ | c0| c1| +---+---+ | 1| 2| +---+---+ -- schema_of_json SELECT schema_of_json('[{"col":0}]'); +---------------------------+ | schema_of_json([{"col":0}]) | +---------------------------+ | ARRAY **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) **** | Funzione | Description | | --- | --- | | array (expr,...) | Restituisce un array con gli elementi dati. | | array\$1append (array, elemento) | Aggiunge l'elemento alla fine dell'array passato come primo argomento. Il tipo di elemento deve essere simile al tipo degli elementi dell'array. All'array viene inoltre aggiunto un elemento nullo. Ma se l'array è passato, è NULL, l'output è NULL | | array\$1compact (matrice) | Rimuove i valori nulli dall'array. | | array\$1contains (array, valore) | Restituisce true se l'array contiene il valore. | | array\$1distinct (array) | Rimuove i valori duplicati dall'array. | | array\$1except (matrice1, matrice2) | Restituisce una matrice degli elementi in array1 ma non in array2, senza duplicati. | | array\$1insert (x, pos, val) | Inserisce val nell'indice pos dell'array x. Gli indici degli array iniziano da 1. L'indice negativo massimo è -1 per il quale la funzione inserisce un nuovo elemento dopo l'ultimo elemento corrente. L'indice superiore alla dimensione dell'array aggiunge l'array o lo precede se l'indice è negativo, con elementi 'null'. | | array\$1intersect (matrice1, matrice2) | Restituisce una matrice degli elementi nell'intersezione di array1 e array2, senza duplicati. | | array\$1join (array, delimiter [, nullReplacement]) | Concatena gli elementi dell'array specificato utilizzando il delimitatore e una stringa opzionale per sostituire i valori null. Se non è impostato alcun valore per NullReplacement, viene filtrato qualsiasi valore nullo. | | array\$1max (matrice) | Restituisce il valore massimo nell'array. NaN è maggiore di qualsiasi elemento non NaN per double/float tipo. Gli elementi NULL vengono ignorati. | | array\$1min (matrice) | Restituisce il valore minimo nell'array. NaN è maggiore di qualsiasi elemento non NaN per double/float tipo. Gli elementi NULL vengono ignorati. | | array\$1position (array, elemento) | Restituisce l'indice (a base 1) del primo elemento corrispondente dell'array se è lungo, oppure 0 se non viene trovata alcuna corrispondenza. | | array\$1prepend (array, elemento) | Aggiunge l'elemento all'inizio dell'array passato come primo argomento. Il tipo di elemento deve essere lo stesso del tipo degli elementi dell'array. All'array viene inoltre aggiunto un elemento nullo. Ma se l'array passato è NULL, l'output è NULL | | array\$1remove (array, elemento) | Rimuove tutti gli elementi uguali all'elemento dall'array. | | array\$1repeat (elemento, conteggio) | Restituisce l'array contenente i tempi di conteggio degli elementi. | | array\$1union (matrice1, matrice2) | Restituisce un array degli elementi nell'unione di array1 e array2, senza duplicati. | | arrays\$1overlap (a1, a2) | Restituisce true se a1 contiene almeno un elemento non nullo presente anche in a2. Se gli array non hanno alcun elemento comune e sono entrambi non vuoti e uno di essi contiene un elemento nullo, viene restituito null, false in caso contrario. | | arrays\$1zip (a1, a2,...) | Restituisce un array unito di strutture in cui la struttura N-esima contiene tutti gli N-esimi valori degli array di input. | | arrayOfArraysappiattire () | Trasforma una matrice di matrici in una singola matrice. | | get (array, index) | Restituisce un elemento dell'array in un determinato indice (basato su 0). Se l'indice punta al di fuori dei limiti dell'array, questa funzione restituisce NULL. | | sequenza (inizio, arresto, passo) | Genera una serie di elementi dall'inizio alla fine (incluso), incrementando passo dopo passo. Il tipo degli elementi restituiti è lo stesso del tipo di espressioni di argomento. I tipi supportati sono: byte, short, integer, long, date, timestamp. Le espressioni di inizio e fine devono avere lo stesso tipo. Se le espressioni di inizio e fine vengono risolte nel tipo «data» o «timestamp», l'espressione step deve risolvere nel tipo «intervallo» o «intervallo anno-mese» o «intervallo giorno-mese», altrimenti nello stesso tipo delle espressioni di inizio e fine. | | shuffle (matrice) | Restituisce una permutazione casuale dell'array dato. | | slice (x, inizio, lunghezza) | Sottoinsiemi dell'array x a partire dall'inizio dell'indice (gli indici dell'array iniziano da 1 o iniziano dalla fine se l'inizio è negativo) con la lunghezza specificata. | | sort\$1array (array [, AscendingOrder]) | Ordina l'array di input in ordine crescente o decrescente in base all'ordine naturale degli elementi dell'array. NaN è maggiore di qualsiasi elemento non NaN per double/float tipo. Gli elementi nulli verranno posizionati all'inizio dell'array restituito in ordine crescente o alla fine dell'array restituito in ordine decrescente. | **Esempi** ``` -- array SELECT array(1, 2, 3); +--------------+ |array(1, 2, 3)| +--------------+ | [1, 2, 3]| +--------------+ -- array_append SELECT array_append(array('b', 'd', 'c', 'a'), 'd'); +----------------------------------+ |array_append(array(b, d, c, a), d)| +----------------------------------+ | [b, d, c, a, d]| +----------------------------------+ SELECT array_append(array(1, 2, 3, null), null); +----------------------------------------+ |array_append(array(1, 2, 3, NULL), NULL)| +----------------------------------------+ | [1, 2, 3, NULL, N...| +----------------------------------------+ SELECT array_append(CAST(null as Array), 2); +---------------------+ |array_append(NULL, 2)| +---------------------+ | NULL| +---------------------+ -- array_compact SELECT array_compact(array(1, 2, 3, null)); +-----------------------------------+ |array_compact(array(1, 2, 3, NULL))| +-----------------------------------+ | [1, 2, 3]| +-----------------------------------+ SELECT array_compact(array("a", "b", "c")); +-----------------------------+ |array_compact(array(a, b, c))| +-----------------------------+ | [a, b, c]| +-----------------------------+ -- array_contains SELECT array_contains(array(1, 2, 3), 2); +---------------------------------+ |array_contains(array(1, 2, 3), 2)| +---------------------------------+ | true| +---------------------------------+ -- array_distinct SELECT array_distinct(array(1, 2, 3, null, 3)); +---------------------------------------+ |array_distinct(array(1, 2, 3, NULL, 3))| +---------------------------------------+ | [1, 2, 3, NULL]| +---------------------------------------+ -- array_except SELECT array_except(array(1, 2, 3), array(1, 3, 5)); +--------------------------------------------+ |array_except(array(1, 2, 3), array(1, 3, 5))| +--------------------------------------------+ | [2]| +--------------------------------------------+ -- array_insert SELECT array_insert(array(1, 2, 3, 4), 5, 5); +-------------------------------------+ |array_insert(array(1, 2, 3, 4), 5, 5)| +-------------------------------------+ | [1, 2, 3, 4, 5]| +-------------------------------------+ SELECT array_insert(array(5, 4, 3, 2), -1, 1); +--------------------------------------+ |array_insert(array(5, 4, 3, 2), -1, 1)| +--------------------------------------+ | [5, 4, 3, 2, 1]| +--------------------------------------+ SELECT array_insert(array(5, 3, 2, 1), -4, 4); +--------------------------------------+ |array_insert(array(5, 3, 2, 1), -4, 4)| +--------------------------------------+ | [5, 4, 3, 2, 1]| +--------------------------------------+ -- array_intersect SELECT array_intersect(array(1, 2, 3), array(1, 3, 5)); +-----------------------------------------------+ |array_intersect(array(1, 2, 3), array(1, 3, 5))| +-----------------------------------------------+ | [1, 3]| +-----------------------------------------------+ -- array_join SELECT array_join(array('hello', 'world'), ' '); +----------------------------------+ |array_join(array(hello, world), )| +----------------------------------+ | hello world| +----------------------------------+ SELECT array_join(array('hello', null ,'world'), ' '); +----------------------------------------+ |array_join(array(hello, NULL, world), )| +----------------------------------------+ | hello world| +----------------------------------------+ SELECT array_join(array('hello', null ,'world'), ' ', ','); +-------------------------------------------+ |array_join(array(hello, NULL, world), , ,)| +-------------------------------------------+ | hello , world| +-------------------------------------------+ -- array_max SELECT array_max(array(1, 20, null, 3)); +--------------------------------+ |array_max(array(1, 20, NULL, 3))| +--------------------------------+ | 20| +--------------------------------+ -- array_min SELECT array_min(array(1, 20, null, 3)); +--------------------------------+ |array_min(array(1, 20, NULL, 3))| +--------------------------------+ | 1| +--------------------------------+ -- array_position SELECT array_position(array(312, 773, 708, 708), 708); +----------------------------------------------+ |array_position(array(312, 773, 708, 708), 708)| +----------------------------------------------+ | 3| +----------------------------------------------+ SELECT array_position(array(312, 773, 708, 708), 414); +----------------------------------------------+ |array_position(array(312, 773, 708, 708), 414)| +----------------------------------------------+ | 0| +----------------------------------------------+ -- array_prepend SELECT array_prepend(array('b', 'd', 'c', 'a'), 'd'); +-----------------------------------+ |array_prepend(array(b, d, c, a), d)| +-----------------------------------+ | [d, b, d, c, a]| +-----------------------------------+ SELECT array_prepend(array(1, 2, 3, null), null); +-----------------------------------------+ |array_prepend(array(1, 2, 3, NULL), NULL)| +-----------------------------------------+ | [NULL, 1, 2, 3, N...| +-----------------------------------------+ SELECT array_prepend(CAST(null as Array), 2); +----------------------+ |array_prepend(NULL, 2)| +----------------------+ | NULL| +----------------------+ -- array_remove SELECT array_remove(array(1, 2, 3, null, 3), 3); +----------------------------------------+ |array_remove(array(1, 2, 3, NULL, 3), 3)| +----------------------------------------+ | [1, 2, NULL]| +----------------------------------------+ -- array_repeat SELECT array_repeat('123', 2); +--------------------+ |array_repeat(123, 2)| +--------------------+ | [123, 123]| +--------------------+ -- array_union SELECT array_union(array(1, 2, 3), array(1, 3, 5)); +-------------------------------------------+ |array_union(array(1, 2, 3), array(1, 3, 5))| +-------------------------------------------+ | [1, 2, 3, 5]| +-------------------------------------------+ -- arrays_overlap SELECT arrays_overlap(array(1, 2, 3), array(3, 4, 5)); +----------------------------------------------+ |arrays_overlap(array(1, 2, 3), array(3, 4, 5))| +----------------------------------------------+ | true| +----------------------------------------------+ -- arrays_zip SELECT arrays_zip(array(1, 2, 3), array(2, 3, 4)); +------------------------------------------+ |arrays_zip(array(1, 2, 3), array(2, 3, 4))| +------------------------------------------+ | [{1, 2}, {2, 3}, ...| +------------------------------------------+ SELECT arrays_zip(array(1, 2), array(2, 3), array(3, 4)); +-------------------------------------------------+ |arrays_zip(array(1, 2), array(2, 3), array(3, 4))| +-------------------------------------------------+ | [{1, 2, 3}, {2, 3...| +-------------------------------------------------+ -- flatten SELECT flatten(array(array(1, 2), array(3, 4))); +----------------------------------------+ |flatten(array(array(1, 2), array(3, 4)))| +----------------------------------------+ | [1, 2, 3, 4]| +----------------------------------------+ -- get SELECT get(array(1, 2, 3), 0); +----------------------+ |get(array(1, 2, 3), 0)| +----------------------+ | 1| +----------------------+ SELECT get(array(1, 2, 3), 3); +----------------------+ |get(array(1, 2, 3), 3)| +----------------------+ | NULL| +----------------------+ SELECT get(array(1, 2, 3), -1); +-----------------------+ |get(array(1, 2, 3), -1)| +-----------------------+ | NULL| +-----------------------+ -- sequence SELECT sequence(1, 5); +---------------+ | sequence(1, 5)| +---------------+ |[1, 2, 3, 4, 5]| +---------------+ SELECT sequence(5, 1); +---------------+ | sequence(5, 1)| +---------------+ |[5, 4, 3, 2, 1]| +---------------+ SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval 1 month); +----------------------------------------------------------------------+ |sequence(to_date(2018-01-01), to_date(2018-03-01), INTERVAL '1' MONTH)| +----------------------------------------------------------------------+ | [2018-01-01, 2018...| +----------------------------------------------------------------------+ SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval '0-1' year to month); +--------------------------------------------------------------------------------+ |sequence(to_date(2018-01-01), to_date(2018-03-01), INTERVAL '0-1' YEAR TO MONTH)| +--------------------------------------------------------------------------------+ | [2018-01-01, 2018...| +--------------------------------------------------------------------------------+ -- shuffle SELECT shuffle(array(1, 20, 3, 5)); +---------------------------+ |shuffle(array(1, 20, 3, 5))| +---------------------------+ | [5, 1, 20, 3]| +---------------------------+ SELECT shuffle(array(1, 20, null, 3)); +------------------------------+ |shuffle(array(1, 20, NULL, 3))| +------------------------------+ | [1, NULL, 20, 3]| +------------------------------+ -- slice SELECT slice(array(1, 2, 3, 4), 2, 2); +------------------------------+ |slice(array(1, 2, 3, 4), 2, 2)| +------------------------------+ | [2, 3]| +------------------------------+ SELECT slice(array(1, 2, 3, 4), -2, 2); +-------------------------------+ |slice(array(1, 2, 3, 4), -2, 2)| +-------------------------------+ | [3, 4]| +-------------------------------+ -- sort_array SELECT sort_array(array('b', 'd', null, 'c', 'a'), true); +-----------------------------------------+ |sort_array(array(b, d, NULL, c, a), true)| +-----------------------------------------+ | [NULL, a, b, c, d]| +-----------------------------------------+ ``` #### Funzioni finestra **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) Le funzioni della finestra operano su un gruppo di righe, denominato finestra, e calcolano un valore restituito per ogni riga in base al gruppo di righe. Le funzioni della finestra sono utili per elaborare attività come il calcolo di una media mobile, il calcolo di una statistica cumulativa o l'accesso al valore delle righe in base alla posizione relativa della riga corrente. **Sintassi** ``` window_function [ nulls_option ] OVER ( [ { PARTITION | DISTRIBUTE } BY partition_col_name = partition_col_val ( [ , ... ] ) ] { ORDER | SORT } BY expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] [ window_frame ] ) ``` **Parametri** + finestra\$1funzione Funzioni di classificazione Sintassi: `RANK | DENSE_RANK | PERCENT_RANK | NTILE | ROW_NUMBER ` Funzioni analitiche Sintassi: `CUME_DIST | LAG | LEAD | NTH_VALUE | FIRST_VALUE | LAST_VALUE ` Funzioni di aggregazione Sintassi: `MAX | MIN | COUNT | SUM | AVG | ... ` + `nulls_option`- Speciifica se ignorare o meno i valori nulli durante la valutazione della funzione finestra. RESPECT NULLS significa non saltare i valori nulli, mentre IGNORE NULLS significa saltare. Se non viene specificato, l'impostazione predefinita è RESPECT NULLS. Sintassi: `{ IGNORE | RESPECT } NULLS ` Nota: `Only LAG` \$1 `LEAD` \$1 `NTH_VALUE` \$1 `FIRST_VALUE` \$1 `LAST_VALUE` può essere usato con`IGNORE NULLS`. + `window_frame`- Specificate su quale riga iniziare la finestra e dove terminarla. Sintassi: `{ RANGE | ROWS } { frame_start | BETWEEN frame_start AND frame_end }` frame\$1start e frame\$1end hanno la seguente sintassi: Sintassi: `UNBOUNDED PRECEDING | offset PRECEDING | CURRENT ROW | offset FOLLOWING | UNBOUNDED FOLLOWING ` offset: specifica l'offset dalla posizione della riga corrente. **Nota** Se frame\$1end viene omesso, il valore predefinito è CURRENT ROW. **Esempi** ``` CREATE TABLE employees (name STRING, dept STRING, salary INT, age INT); INSERT INTO employees VALUES ("Lisa", "Sales", 10000, 35); INSERT INTO employees VALUES ("Evan", "Sales", 32000, 38); INSERT INTO employees VALUES ("Fred", "Engineering", 21000, 28); INSERT INTO employees VALUES ("Alex", "Sales", 30000, 33); INSERT INTO employees VALUES ("Tom", "Engineering", 23000, 33); INSERT INTO employees VALUES ("Jane", "Marketing", 29000, 28); INSERT INTO employees VALUES ("Jeff", "Marketing", 35000, 38); INSERT INTO employees VALUES ("Paul", "Engineering", 29000, 23); INSERT INTO employees VALUES ("Chloe", "Engineering", 23000, 25); SELECT * FROM employees; +-----+-----------+------+-----+ | name| dept|salary| age| +-----+-----------+------+-----+ |Chloe|Engineering| 23000| 25| | Fred|Engineering| 21000| 28| | Paul|Engineering| 29000| 23| |Helen| Marketing| 29000| 40| | Tom|Engineering| 23000| 33| | Jane| Marketing| 29000| 28| | Jeff| Marketing| 35000| 38| | Evan| Sales| 32000| 38| | Lisa| Sales| 10000| 35| | Alex| Sales| 30000| 33| +-----+-----------+------+-----+ SELECT name, dept, salary, RANK() OVER (PARTITION BY dept ORDER BY salary) AS rank FROM employees; +-----+-----------+------+----+ | name| dept|salary|rank| +-----+-----------+------+----+ | Lisa| Sales| 10000| 1| | Alex| Sales| 30000| 2| | Evan| Sales| 32000| 3| | Fred|Engineering| 21000| 1| | Tom|Engineering| 23000| 2| |Chloe|Engineering| 23000| 2| | Paul|Engineering| 29000| 4| |Helen| Marketing| 29000| 1| | Jane| Marketing| 29000| 1| | Jeff| Marketing| 35000| 3| +-----+-----------+------+----+ SELECT name, dept, salary, DENSE_RANK() OVER (PARTITION BY dept ORDER BY salary ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS dense_rank FROM employees; +-----+-----------+------+----------+ | name| dept|salary|dense_rank| +-----+-----------+------+----------+ | Lisa| Sales| 10000| 1| | Alex| Sales| 30000| 2| | Evan| Sales| 32000| 3| | Fred|Engineering| 21000| 1| | Tom|Engineering| 23000| 2| |Chloe|Engineering| 23000| 2| | Paul|Engineering| 29000| 3| |Helen| Marketing| 29000| 1| | Jane| Marketing| 29000| 1| | Jeff| Marketing| 35000| 2| +-----+-----------+------+----------+ SELECT name, dept, age, CUME_DIST() OVER (PARTITION BY dept ORDER BY age RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS cume_dist FROM employees; +-----+-----------+------+------------------+ | name| dept|age | cume_dist| +-----+-----------+------+------------------+ | Alex| Sales| 33|0.3333333333333333| | Lisa| Sales| 35|0.6666666666666666| | Evan| Sales| 38| 1.0| | Paul|Engineering| 23| 0.25| |Chloe|Engineering| 25| 0.75| | Fred|Engineering| 28| 0.25| | Tom|Engineering| 33| 1.0| | Jane| Marketing| 28|0.3333333333333333| | Jeff| Marketing| 38|0.6666666666666666| |Helen| Marketing| 40| 1.0| +-----+-----------+------+------------------+ SELECT name, dept, salary, MIN(salary) OVER (PARTITION BY dept ORDER BY salary) AS min FROM employees; +-----+-----------+------+-----+ | name| dept|salary| min| +-----+-----------+------+-----+ | Lisa| Sales| 10000|10000| | Alex| Sales| 30000|10000| | Evan| Sales| 32000|10000| |Helen| Marketing| 29000|29000| | Jane| Marketing| 29000|29000| | Jeff| Marketing| 35000|29000| | Fred|Engineering| 21000|21000| | Tom|Engineering| 23000|21000| |Chloe|Engineering| 23000|21000| | Paul|Engineering| 29000|21000| +-----+-----------+------+-----+ SELECT name, salary, LAG(salary) OVER (PARTITION BY dept ORDER BY salary) AS lag, LEAD(salary, 1, 0) OVER (PARTITION BY dept ORDER BY salary) AS lead FROM employees; +-----+-----------+------+-----+-----+ | name| dept|salary| lag| lead| +-----+-----------+------+-----+-----+ | Lisa| Sales| 10000|NULL |30000| | Alex| Sales| 30000|10000|32000| | Evan| Sales| 32000|30000| 0| | Fred|Engineering| 21000| NULL|23000| |Chloe|Engineering| 23000|21000|23000| | Tom|Engineering| 23000|23000|29000| | Paul|Engineering| 29000|23000| 0| |Helen| Marketing| 29000| NULL|29000| | Jane| Marketing| 29000|29000|35000| | Jeff| Marketing| 35000|29000| 0| +-----+-----------+------+-----+-----+ SELECT id, v, LEAD(v, 0) IGNORE NULLS OVER w lead, LAG(v, 0) IGNORE NULLS OVER w lag, NTH_VALUE(v, 2) IGNORE NULLS OVER w nth_value, FIRST_VALUE(v) IGNORE NULLS OVER w first_value, LAST_VALUE(v) IGNORE NULLS OVER w last_value FROM test_ignore_null WINDOW w AS (ORDER BY id) ORDER BY id; +--+----+----+----+---------+-----------+----------+ |id| v|lead| lag|nth_value|first_value|last_value| +--+----+----+----+---------+-----------+----------+ | 0|NULL|NULL|NULL| NULL| NULL| NULL| | 1| x| x| x| NULL| x| x| | 2|NULL|NULL|NULL| NULL| x| x| | 3|NULL|NULL|NULL| NULL| x| x| | 4| y| y| y| y| x| y| | 5|NULL|NULL|NULL| y| x| y| | 6| z| z| z| y| x| z| | 7| v| v| v| y| x| v| | 8|NULL|NULL|NULL| y| x| v| +--+----+----+----+---------+-----------+----------+ ``` #### Funzioni di conversione **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) **** | Funzione | Description | | --- | --- | | bigint (expr) | Trasmette il valore `expr` al tipo di dati di destinazione `bigint`. | | binario (expr) | Trasmette il valore `expr` al tipo di dati di destinazione `binary`. | | booleano (expr) | Trasmette il valore `expr` al tipo di dati di destinazione `boolean`. | | cast (tipo expr AS) | Trasmette il valore `expr` al tipo di dati di destinazione `type`. | | data (expr) | Trasmette il valore `expr` al tipo di dati di destinazione `date`. | | decimale (expr) | Trasmette il valore `expr` al tipo di dati di destinazione `decimal`. | | doppio (expr) | Trasmette il valore `expr` al tipo di dati di destinazione `double`. | | float (expr) | Trasmette il valore `expr` al tipo di dati di destinazione `float`. | | int (expr) | Trasmette il valore `expr` al tipo di dati di destinazione `int`. | | smallint (expr) | Trasmette il valore `expr` al tipo di dati di destinazione `smallint`. | | stringa (expr) | Trasmette il valore `expr` al tipo di dati di destinazione `string`. | | timestamp (expr) | Trasmette il valore `expr` al tipo di dati di destinazione `timestamp`. | | tinyint (expr) | Trasmette il valore `expr` al tipo di dati di destinazione `tinyint`. | **Esempi** ``` -- cast SELECT cast(field as int); +---------------+ |CAST(field AS INT)| +---------------+ | 10| +---------------+ ``` #### Funzioni di predicato **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) **** | Funzione | Description | | --- | --- | | \$1 espr | Logico no. | | espr 1 < espr 2 | Restituisce vero se `expr1` è minore di `expr2`. | | espr 1 <= espr 2 | Restituisce vero se `expr1` è minore o uguale a `expr2`. | | expr1 <=> espr 2 | Restituisce lo stesso risultato dell'operatore EQUAL (=) per gli operandi non nulli, ma restituisce true se entrambi sono nulli, false se uno di essi è nullo. | | espr 1 = espr 2 | Restituisce true se `expr1` è uguale a `expr2`, altrimenti restituisce falso. | | espr 1 == espr 2 | Restituisce true se `expr1` è uguale a `expr2`, altrimenti restituisce false. | | expr1 > expr2 | Restituisce vero se `expr1` è maggiore di `expr2`. | | espr 1 >= espr 2 | Restituisce vero se `expr1` è maggiore o uguale a `expr2`. | | expr1 ed expr2 | AND logico. | | pattern simile a una stella [ESCAPE escape] | Restituisce true se str corrisponde a `pattern` con `escape` senza distinzione tra maiuscole e minuscole, null se alcuni argomenti sono nulli, false in caso contrario. | | espr1 in (expr2, expr3,...) | Restituisce true se `expr` è uguale a qualsiasi ValN. | | isnan (expr) | Restituisce true se `expr` è NaN, altrimenti restituisce false. | | isnotnull (expr) | Restituisce true se `expr` non è nullo, altrimenti restituisce false. | | isnull (espr) | Restituisce true se `expr` è nullo, altrimenti restituisce falso. | | str like pattern [ESCAPE escape] | Restituisce true se str corrisponde a `pattern` con `escape`, null se qualche argomento è nullo, falso altrimenti. | | non expr | Logico no. | | expr1 o expr2 | OR logico. | | regexp (str, regexp) | Restituisce true se `str` corrisponde a `regexp`, altrimenti restituisce false. | | regexp\$1like (str, regexp) | Restituisce true se `str` corrisponde a `regexp`, altrimenti restituisce false. | | rlike (str, regexp) | Restituisce true se `str` corrisponde a `regexp`, altrimenti restituisce false. | **Esempi** ``` -- ! SELECT ! true; +----------+ |(NOT true)| +----------+ | false| +----------+ SELECT ! false; +-----------+ |(NOT false)| +-----------+ | true| +-----------+ SELECT ! NULL; +----------+ |(NOT NULL)| +----------+ | NULL| +----------+ -- < SELECT to_date('2009-07-30 04:17:52') < to_date('2009-07-30 04:17:52'); +-------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) < to_date(2009-07-30 04:17:52))| +-------------------------------------------------------------+ | false| +-------------------------------------------------------------+ SELECT to_date('2009-07-30 04:17:52') < to_date('2009-08-01 04:17:52'); +-------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) < to_date(2009-08-01 04:17:52))| +-------------------------------------------------------------+ | true| +-------------------------------------------------------------+ SELECT 1 < NULL; +----------+ |(1 < NULL)| +----------+ | NULL| +----------+ -- <= SELECT 2 <= 2; +--------+ |(2 <= 2)| +--------+ | true| +--------+ SELECT 1.0 <= '1'; +----------+ |(1.0 <= 1)| +----------+ | true| +----------+ SELECT to_date('2009-07-30 04:17:52') <= to_date('2009-07-30 04:17:52'); +--------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) <= to_date(2009-07-30 04:17:52))| +--------------------------------------------------------------+ | true| +--------------------------------------------------------------+ SELECT to_date('2009-07-30 04:17:52') <= to_date('2009-08-01 04:17:52'); +--------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) <= to_date(2009-08-01 04:17:52))| +--------------------------------------------------------------+ | true| +--------------------------------------------------------------+ SELECT 1 <= NULL; +-----------+ |(1 <= NULL)| +-----------+ | NULL| +-----------+ -- <=> SELECT 2 <=> 2; +---------+ |(2 <=> 2)| +---------+ | true| +---------+ SELECT 1 <=> '1'; +---------+ |(1 <=> 1)| +---------+ | true| +---------+ SELECT true <=> NULL; +---------------+ |(true <=> NULL)| +---------------+ | false| +---------------+ SELECT NULL <=> NULL; +---------------+ |(NULL <=> NULL)| +---------------+ | true| +---------------+ -- = SELECT 2 = 2; +-------+ |(2 = 2)| +-------+ | true| +-------+ SELECT 1 = '1'; +-------+ |(1 = 1)| +-------+ | true| +-------+ SELECT true = NULL; +-------------+ |(true = NULL)| +-------------+ | NULL| +-------------+ SELECT NULL = NULL; +-------------+ |(NULL = NULL)| +-------------+ | NULL| +-------------+ -- == SELECT 2 == 2; +-------+ |(2 = 2)| +-------+ | true| +-------+ SELECT 1 == '1'; +-------+ |(1 = 1)| +-------+ | true| +-------+ SELECT true == NULL; +-------------+ |(true = NULL)| +-------------+ | NULL| +-------------+ SELECT NULL == NULL; +-------------+ |(NULL = NULL)| +-------------+ | NULL| +-------------+ -- > SELECT 2 > 1; +-------+ |(2 > 1)| +-------+ | true| +-------+ SELECT 2 > 1.1; +-------+ |(2 > 1)| +-------+ | true| +-------+ SELECT to_date('2009-07-30 04:17:52') > to_date('2009-07-30 04:17:52'); +-------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) > to_date(2009-07-30 04:17:52))| +-------------------------------------------------------------+ | false| +-------------------------------------------------------------+ SELECT to_date('2009-07-30 04:17:52') > to_date('2009-08-01 04:17:52'); +-------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) > to_date(2009-08-01 04:17:52))| +-------------------------------------------------------------+ | false| +-------------------------------------------------------------+ SELECT 1 > NULL; +----------+ |(1 > NULL)| +----------+ | NULL| +----------+ -- >= SELECT 2 >= 1; +--------+ |(2 >= 1)| +--------+ | true| +--------+ SELECT 2.0 >= '2.1'; +------------+ |(2.0 >= 2.1)| +------------+ | false| +------------+ SELECT to_date('2009-07-30 04:17:52') >= to_date('2009-07-30 04:17:52'); +--------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) >= to_date(2009-07-30 04:17:52))| +--------------------------------------------------------------+ | true| +--------------------------------------------------------------+ SELECT to_date('2009-07-30 04:17:52') >= to_date('2009-08-01 04:17:52'); +--------------------------------------------------------------+ |(to_date(2009-07-30 04:17:52) >= to_date(2009-08-01 04:17:52))| +--------------------------------------------------------------+ | false| +--------------------------------------------------------------+ SELECT 1 >= NULL; +-----------+ |(1 >= NULL)| +-----------+ | NULL| +-----------+ -- and SELECT true and true; +---------------+ |(true AND true)| +---------------+ | true| +---------------+ SELECT true and false; +----------------+ |(true AND false)| +----------------+ | false| +----------------+ SELECT true and NULL; +---------------+ |(true AND NULL)| +---------------+ | NULL| +---------------+ SELECT false and NULL; +----------------+ |(false AND NULL)| +----------------+ | false| +----------------+ -- ilike SELECT ilike('Wagon', '_Agon'); +-------------------+ |ilike(Wagon, _Agon)| +-------------------+ | true| +-------------------+ SELECT '%SystemDrive%\Users\John' ilike '\%SystemDrive\%\\users%'; +--------------------------------------------------------+ |ilike(%SystemDrive%\Users\John, \%SystemDrive\%\\users%)| +--------------------------------------------------------+ | true| +--------------------------------------------------------+ SELECT '%SystemDrive%\\USERS\\John' ilike '\%SystemDrive\%\\\\Users%'; +--------------------------------------------------------+ |ilike(%SystemDrive%\USERS\John, \%SystemDrive\%\\Users%)| +--------------------------------------------------------+ | true| +--------------------------------------------------------+ SELECT '%SystemDrive%/Users/John' ilike '/%SYSTEMDrive/%//Users%' ESCAPE '/'; +--------------------------------------------------------+ |ilike(%SystemDrive%/Users/John, /%SYSTEMDrive/%//Users%)| +--------------------------------------------------------+ | true| +--------------------------------------------------------+ -- in SELECT 1 in(1, 2, 3); +----------------+ |(1 IN (1, 2, 3))| +----------------+ | true| +----------------+ SELECT 1 in(2, 3, 4); +----------------+ |(1 IN (2, 3, 4))| +----------------+ | false| +----------------+ SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 1), named_struct('a', 1, 'b', 3)); +----------------------------------------------------------------------------------+ |(named_struct(a, 1, b, 2) IN (named_struct(a, 1, b, 1), named_struct(a, 1, b, 3)))| +----------------------------------------------------------------------------------+ | false| +----------------------------------------------------------------------------------+ SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 2), named_struct('a', 1, 'b', 3)); +----------------------------------------------------------------------------------+ |(named_struct(a, 1, b, 2) IN (named_struct(a, 1, b, 2), named_struct(a, 1, b, 3)))| +----------------------------------------------------------------------------------+ | true| +----------------------------------------------------------------------------------+ -- isnan SELECT isnan(cast('NaN' as double)); +--------------------------+ |isnan(CAST(NaN AS DOUBLE))| +--------------------------+ | true| +--------------------------+ -- isnotnull SELECT isnotnull(1); +---------------+ |(1 IS NOT NULL)| +---------------+ | true| +---------------+ -- isnull SELECT isnull(1); +-----------+ |(1 IS NULL)| +-----------+ | false| +-----------+ -- like SELECT like('Wagon', '_Agon'); +----------------+ |Wagon LIKE _Agon| +----------------+ | true| +----------------+ -- not SELECT not true; +----------+ |(NOT true)| +----------+ | false| +----------+ SELECT not false; +-----------+ |(NOT false)| +-----------+ | true| +-----------+ SELECT not NULL; +----------+ |(NOT NULL)| +----------+ | NULL| +----------+ -- or SELECT true or false; +---------------+ |(true OR false)| +---------------+ | true| +---------------+ SELECT false or false; +----------------+ |(false OR false)| +----------------+ | false| +----------------+ SELECT true or NULL; +--------------+ |(true OR NULL)| +--------------+ | true| +--------------+ SELECT false or NULL; +---------------+ |(false OR NULL)| +---------------+ | NULL| +---------------+ ``` #### Funzioni della mappa **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi[Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql). **** | Funzione | Description | | --- | --- | | element\$1at (array, indice) | Restituisce un elemento dell'array in un determinato indice (a base 1). | | element\$1at (mappa, chiave) | Restituisce il valore per una determinata chiave. La funzione restituisce NULL se la chiave non è contenuta nella mappa. | | mappa (chiave0, valore0, chiave1, valore1,...) | Crea una mappa con le coppie date. key/value | | map\$1concat (mappa,...) | Restituisce l'unione di tutte le mappe fornite | | map\$1contains\$1key (mappa, chiave) | Restituisce true se la mappa contiene la chiave. | | map\$1entries (mappa) | Restituisce un array non ordinato di tutte le voci nella mappa data. | | map\$1from\$1arrays (chiavi, valori) | Crea una mappa con un paio di array dati. key/value Tutti gli elementi nelle chiavi non devono essere nulli | | map\$1from\$1entries () arrayOfEntries | Restituisce una mappa creata dall'array di voci specificato. | | map\$1keys (mappa) | Restituisce un array non ordinato contenente le chiavi della mappa. | | map\$1values (mappa) | Restituisce un array non ordinato contenente i valori della mappa. | | str\$1to\$1map (text [, pairDelim [,]]) keyValueDelim | Crea una mappa dopo aver suddiviso il testo in coppie chiave/valore utilizzando delimitatori. I delimitatori predefiniti sono ',' per `PairDelim` e ':' per ``. keyValueDelim Sia `PairDelim` che `` vengono trattati come espressioni regolari. keyValueDelim | | try\$1element\$1at (array, indice) | Restituisce un elemento dell'array in un determinato indice (a base 1). Se l'indice è 0, il sistema genererà un errore. Se index < 0, accede agli elementi dall'ultimo al primo. La funzione restituisce sempre NULL se l'indice supera la lunghezza dell'array. | | try\$1element\$1at (mappa, chiave) | Restituisce il valore per una determinata chiave. La funzione restituisce sempre NULL se la chiave non è contenuta nella mappa. | **Esempi** ``` -- element_at SELECT element_at(array(1, 2, 3), 2); +-----------------------------+ |element_at(array(1, 2, 3), 2)| +-----------------------------+ | 2| +-----------------------------+ SELECT element_at(map(1, 'a', 2, 'b'), 2); +------------------------------+ |element_at(map(1, a, 2, b), 2)| +------------------------------+ | b| +------------------------------+ -- map SELECT map(1.0, '2', 3.0, '4'); +--------------------+ | map(1.0, 2, 3.0, 4)| +--------------------+ |{1.0 -> 2, 3.0 -> 4}| +--------------------+ -- map_concat SELECT map_concat(map(1, 'a', 2, 'b'), map(3, 'c')); +--------------------------------------+ |map_concat(map(1, a, 2, b), map(3, c))| +--------------------------------------+ | {1 -> a, 2 -> b, ...| +--------------------------------------+ -- map_contains_key SELECT map_contains_key(map(1, 'a', 2, 'b'), 1); +------------------------------------+ |map_contains_key(map(1, a, 2, b), 1)| +------------------------------------+ | true| +------------------------------------+ SELECT map_contains_key(map(1, 'a', 2, 'b'), 3); +------------------------------------+ |map_contains_key(map(1, a, 2, b), 3)| +------------------------------------+ | false| +------------------------------------+ -- map_entries SELECT map_entries(map(1, 'a', 2, 'b')); +----------------------------+ |map_entries(map(1, a, 2, b))| +----------------------------+ | [{1, a}, {2, b}]| +----------------------------+ -- map_from_arrays SELECT map_from_arrays(array(1.0, 3.0), array('2', '4')); +---------------------------------------------+ |map_from_arrays(array(1.0, 3.0), array(2, 4))| +---------------------------------------------+ | {1.0 -> 2, 3.0 -> 4}| +---------------------------------------------+ -- map_from_entries SELECT map_from_entries(array(struct(1, 'a'), struct(2, 'b'))); +---------------------------------------------------+ |map_from_entries(array(struct(1, a), struct(2, b)))| +---------------------------------------------------+ | {1 -> a, 2 -> b}| +---------------------------------------------------+ -- map_keys SELECT map_keys(map(1, 'a', 2, 'b')); +-------------------------+ |map_keys(map(1, a, 2, b))| +-------------------------+ | [1, 2]| +-------------------------+ -- map_values SELECT map_values(map(1, 'a', 2, 'b')); +---------------------------+ |map_values(map(1, a, 2, b))| +---------------------------+ | [a, b]| +---------------------------+ -- str_to_map SELECT str_to_map('a:1,b:2,c:3', ',', ':'); +-----------------------------+ |str_to_map(a:1,b:2,c:3, ,, :)| +-----------------------------+ | {a -> 1, b -> 2, ...| +-----------------------------+ SELECT str_to_map('a'); +-------------------+ |str_to_map(a, ,, :)| +-------------------+ | {a -> NULL}| +-------------------+ -- try_element_at SELECT try_element_at(array(1, 2, 3), 2); +---------------------------------+ |try_element_at(array(1, 2, 3), 2)| +---------------------------------+ | 2| +---------------------------------+ SELECT try_element_at(map(1, 'a', 2, 'b'), 2); +----------------------------------+ |try_element_at(map(1, a, 2, b), 2)| +----------------------------------+ | b| +----------------------------------+ ``` #### Funzioni matematiche **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) **** | Funzione | Description | | --- | --- | | espr 1% expr 2 | Restituisce il resto dopo `expr1`/`expr2`. | | espr 1 \$1 espr 2 | Restituisce `expr1`\$1`expr2`. | | espr 1 \$1 espr 2 | Restituisce `expr1`\$1`expr2`. | | espr 1 - espr 2 | Restituisce `expr1`-`expr2`. | | espr 1/espr 2 | Restituisce `expr1`/`expr2`. Esegue sempre la divisione in virgola mobile. | | abs (expr) | Restituisce il valore assoluto del valore numerico o dell'intervallo. | | acos (expr) | Restituisce il coseno inverso (alias arc coseno) di `expr`, come se fosse calcolato da `java.lang.math.ACOS`. | | acosh (expr) | Restituisce il coseno iperbolico inverso di `expr`. | | asino (expr) | Restituisce il seno inverso (alias arc sine) l'arco sin di `expr`, come se fosse calcolato da `java.lang.Math.ASIN`. | | asing (expr) | Restituisce il seno iperbolico inverso di `expr`. | | satan (expr) | Restituisce la tangente inversa (alias arcotangente) di `expr`, come se fosse calcolata da `java.lang.math.ATAN` | | atan2 (ExprY, expRX) | Restituisce l'angolo in radianti tra l'asse x positivo di un piano e il punto dato dalle coordinate (`expRX`, `Expry`), come se fosse calcolato da `java.lang.math.ATAN2`. | | atanh (expr) | Restituisce la tangente iperbolica inversa di `expr`. | | bin (expr) | Restituisce la rappresentazione in formato stringa del valore lungo `expr` rappresentato in binario. | | terreno (expr, d) | Restituisce `expr` arrotondato alle cifre decimali `d` utilizzando la modalità di arrotondamento HALF\$1EVEN. | | cbrt (espr) | Restituisce la radice cubica di `expr`. | | ceil (expr [, scala]) | Restituisce il numero più piccolo dopo l'arrotondamento per eccesso che non sia inferiore a `expr`. È possibile specificare un parametro `scale` opzionale per controllare il comportamento di arrotondamento. | | soffitto (expr [, scale]) | Restituisce il numero più piccolo dopo l'arrotondamento per eccesso che non sia inferiore a `expr`. È possibile specificare un parametro `scale` opzionale per controllare il comportamento di arrotondamento. | | conv (num, from\$1base, to\$1base) | Converte `num` da `from\$1base` a `to\$1base`. | | cos (expr) | Restituisce il coseno di `expr`, come se fosse calcolato da `java.lang.math.COS`. | | cosh (expr) | Restituisce il coseno iperbolico di `expr`, come se fosse calcolato da `java.lang.math.cosh`. | | cot (expr) | Restituisce la cotangente di `expr`, come se fosse calcolata da `1/java.lang.math.TAN`. | | csc (expr) | Restituisce la cosecante di `expr`, come se fosse calcolata da `1/java.lang.math.sin`. | | gradi (expr) | Converte i radianti in gradi. | | espr 1 div expr 2 | Dividi `expr1` per `expr2`. Restituisce NULL se un operando è NULL o `expr2` è 0. Il risultato viene espresso troppo a lungo. | | (e) | Restituisce il numero di Eulero, e. | | exp (espr) | Restituisce e alla potenza di `expr`. | | expm1 (expr) - Restituisce exp (`expr`) | 1 | | fattoriale (expr) | Restituisce il fattoriale di `expr`. `expr` è [0.. 20]. Altrimenti, null. | | pavimento (expr [, scala]) | Restituisce il numero più grande dopo l'arrotondamento per difetto che non sia maggiore di `expr`. È possibile specificare un parametro `scale` opzionale per controllare il comportamento di arrotondamento. | | massimo (expr,...) | Restituisce il valore massimo di tutti i parametri, ignorando i valori nulli. | | esadecimale (expr) | Converte `expr` in esadecimale. | | hypot (espr 1, espr 2) | Restituisce sqrt (`expr1`\$1\$12 \$1 `expr2`\$1\$12). | | minimo (expr,...) | Restituisce il valore minimo di tutti i parametri, ignorando i valori nulli. | | ln (expr) | Restituisce il logaritmo naturale (base e) di `expr`. | | log (base, expr) | Restituisce il logaritmo di `expr` con `base`. | | log10 (expr) | Restituisce il logaritmo di `expr` con base 10. | | log1p (expr) | Restituisce log (1 \$1 `expr`). | | log2 (espr) | Restituisce il logaritmo di `expr` con base 2. | | espr 1 mod expr 2 | Restituisce il resto dopo `expr1`/`expr2`. | | negativo (expr) | Restituisce il valore negato di `expr`. | | pi () | Restituisce pi. | | pmod (espr 1, espr 2) | Restituisce il valore positivo di `expr1` mod `expr2`. | | positivo (expr) | Restituisce il valore di `expr`. | | pow (espr 1, espr 2) | Eleva `expr1` alla potenza di `expr2`. | | potenza (expr1, expr2) | Eleva `expr1` alla potenza di `expr2`. | | radianti (expr) | Converte i gradi in radianti. | | rand ([seme]) | Restituisce un valore casuale con valori indipendenti e distribuiti in modo identico (i.i.d.) uniformemente distribuiti in [0, 1). | | randn ([seme]) | Restituisce un valore casuale con valori indipendenti e distribuiti in modo identico (i.i.d.) tratti dalla distribuzione normale standard. | | casuale ([seme]) | Restituisce un valore casuale con valori indipendenti e distribuiti in modo identico (i.i.d.) uniformemente in [0, 1). | | stampa (expr) | Restituisce il valore doppio più vicino all'argomento ed è uguale a un numero intero matematico. | | rotondo (expr, d) | Restituisce `expr` arrotondato alle cifre decimali `d` utilizzando la modalità di arrotondamento HALF\$1UP. | | sec (expr) | Restituisce la secante di `expr`, come se fosse calcolata da `1/java.lang.math.COS`. | | shiftleft (base, expr) | Spostamento bit per bit a sinistra. | | segno (expr) | Restituisce -1,0, 0,0 o 1,0 poiché `expr` è negativo, 0 o positivo. | | segno (expr) | Restituisce -1,0, 0,0 o 1,0 poiché `expr` è negativo, 0 o positivo. | | sin (espr) | Restituisce il seno di `expr`, come se fosse calcolato da `java.lang.math.sin`. | | sinh (expr) | Restituisce il seno iperbolico di `expr`, come se fosse calcolato da `java.lang.math.SINH`. | | sqrt (expr) | Restituisce la radice quadrata di `expr`. | | tan (expr) | Restituisce la tangente di `expr`, come se fosse calcolata da `java.lang.math.tan`. | | tanh (expr) | Restituisce la tangente iperbolica di `expr`, come se fosse calcolata da `java.lang.math.TANH`. | | try\$1add (expr1, expr2) | Restituisce la somma di `expr1`e `expr2` e il risultato è nullo in caso di overflow. I tipi di input accettabili sono gli stessi con l'operatore `\$1`. | | try\$1divide (dividendo, divisore) | Restituisce `dividend`/`divisor`. Esegue sempre la divisione in virgola mobile. Il suo risultato è sempre nullo se `expr2` è 0. `dividend` deve essere un numero o un intervallo. `divisore` deve essere un valore numerico. | | try\$1multiply (espr 1, espr 2) | Restituisce `expr1`\$1`expr2` e il risultato è nullo in caso di overflow. I tipi di input accettabili sono gli stessi con l'operatore `\$1`. | | try\$1sottract (expr1, expr2) | Restituisce `expr1`-`expr2` e il risultato è nullo in overflow. I tipi di input accettabili sono gli stessi con l'operatore `-`. | | unhex (expr) | Converte `expr` esadecimale in binario. | | width\$1bucket (value, min\$1value, max\$1value, num\$1bucket) | Restituisce il numero del bucket a cui verrà assegnato `value` in un istogramma di equilarghezza con bucket `num\$1bucket`, nell'intervallo da `min\$1value` a `max\$1value`.» | **Esempi** ``` -- % SELECT 2 % 1.8; +---------+ |(2 % 1.8)| +---------+ | 0.2| +---------+ SELECT MOD(2, 1.8); +-----------+ |mod(2, 1.8)| +-----------+ | 0.2| +-----------+ -- * SELECT 2 * 3; +-------+ |(2 * 3)| +-------+ | 6| +-------+ -- + SELECT 1 + 2; +-------+ |(1 + 2)| +-------+ | 3| +-------+ -- - SELECT 2 - 1; +-------+ |(2 - 1)| +-------+ | 1| +-------+ -- / SELECT 3 / 2; +-------+ |(3 / 2)| +-------+ | 1.5| +-------+ SELECT 2L / 2L; +-------+ |(2 / 2)| +-------+ | 1.0| +-------+ -- abs SELECT abs(-1); +-------+ |abs(-1)| +-------+ | 1| +-------+ SELECT abs(INTERVAL -'1-1' YEAR TO MONTH); +----------------------------------+ |abs(INTERVAL '-1-1' YEAR TO MONTH)| +----------------------------------+ | INTERVAL '1-1' YE...| +----------------------------------+ -- acos SELECT acos(1); +-------+ |ACOS(1)| +-------+ | 0.0| +-------+ SELECT acos(2); +-------+ |ACOS(2)| +-------+ | NaN| +-------+ -- acosh SELECT acosh(1); +--------+ |ACOSH(1)| +--------+ | 0.0| +--------+ SELECT acosh(0); +--------+ |ACOSH(0)| +--------+ | NaN| +--------+ -- asin SELECT asin(0); +-------+ |ASIN(0)| +-------+ | 0.0| +-------+ SELECT asin(2); +-------+ |ASIN(2)| +-------+ | NaN| +-------+ -- asinh SELECT asinh(0); +--------+ |ASINH(0)| +--------+ | 0.0| +--------+ -- atan SELECT atan(0); +-------+ |ATAN(0)| +-------+ | 0.0| +-------+ -- atan2 SELECT atan2(0, 0); +-----------+ |ATAN2(0, 0)| +-----------+ | 0.0| +-----------+ -- atanh SELECT atanh(0); +--------+ |ATANH(0)| +--------+ | 0.0| +--------+ SELECT atanh(2); +--------+ |ATANH(2)| +--------+ | NaN| +--------+ -- bin SELECT bin(13); +-------+ |bin(13)| +-------+ | 1101| +-------+ SELECT bin(-13); +--------------------+ | bin(-13)| +--------------------+ |11111111111111111...| +--------------------+ SELECT bin(13.3); +---------+ |bin(13.3)| +---------+ | 1101| +---------+ -- bround SELECT bround(2.5, 0); +--------------+ |bround(2.5, 0)| +--------------+ | 2| +--------------+ SELECT bround(25, -1); +--------------+ |bround(25, -1)| +--------------+ | 20| +--------------+ -- cbrt SELECT cbrt(27.0); +----------+ |CBRT(27.0)| +----------+ | 3.0| +----------+ -- ceil SELECT ceil(-0.1); +----------+ |CEIL(-0.1)| +----------+ | 0| +----------+ SELECT ceil(5); +-------+ |CEIL(5)| +-------+ | 5| +-------+ SELECT ceil(3.1411, 3); +---------------+ |ceil(3.1411, 3)| +---------------+ | 3.142| +---------------+ SELECT ceil(3.1411, -3); +----------------+ |ceil(3.1411, -3)| +----------------+ | 1000| +----------------+ -- ceiling SELECT ceiling(-0.1); +-------------+ |ceiling(-0.1)| +-------------+ | 0| +-------------+ SELECT ceiling(5); +----------+ |ceiling(5)| +----------+ | 5| +----------+ SELECT ceiling(3.1411, 3); +------------------+ |ceiling(3.1411, 3)| +------------------+ | 3.142| +------------------+ SELECT ceiling(3.1411, -3); +-------------------+ |ceiling(3.1411, -3)| +-------------------+ | 1000| +-------------------+ -- conv SELECT conv('100', 2, 10); +----------------+ |conv(100, 2, 10)| +----------------+ | 4| +----------------+ SELECT conv(-10, 16, -10); +------------------+ |conv(-10, 16, -10)| +------------------+ | -16| +------------------+ -- cos SELECT cos(0); +------+ |COS(0)| +------+ | 1.0| +------+ -- cosh SELECT cosh(0); +-------+ |COSH(0)| +-------+ | 1.0| +-------+ -- cot SELECT cot(1); +------------------+ | COT(1)| +------------------+ |0.6420926159343306| +------------------+ -- csc SELECT csc(1); +------------------+ | CSC(1)| +------------------+ |1.1883951057781212| +------------------+ -- degrees SELECT degrees(3.141592653589793); +--------------------------+ |DEGREES(3.141592653589793)| +--------------------------+ | 180.0| +--------------------------+ -- div SELECT 3 div 2; +---------+ |(3 div 2)| +---------+ | 1| +---------+ SELECT INTERVAL '1-1' YEAR TO MONTH div INTERVAL '-1' MONTH; +------------------------------------------------------+ |(INTERVAL '1-1' YEAR TO MONTH div INTERVAL '-1' MONTH)| +------------------------------------------------------+ | -13| +------------------------------------------------------+ -- e SELECT e(); +-----------------+ | E()| +-----------------+ |2.718281828459045| +-----------------+ -- exp SELECT exp(0); +------+ |EXP(0)| +------+ | 1.0| +------+ -- expm1 SELECT expm1(0); +--------+ |EXPM1(0)| +--------+ | 0.0| +--------+ -- factorial SELECT factorial(5); +------------+ |factorial(5)| +------------+ | 120| +------------+ -- floor SELECT floor(-0.1); +-----------+ |FLOOR(-0.1)| +-----------+ | -1| +-----------+ SELECT floor(5); +--------+ |FLOOR(5)| +--------+ | 5| +--------+ SELECT floor(3.1411, 3); +----------------+ |floor(3.1411, 3)| +----------------+ | 3.141| +----------------+ SELECT floor(3.1411, -3); +-----------------+ |floor(3.1411, -3)| +-----------------+ | 0| +-----------------+ -- greatest SELECT greatest(10, 9, 2, 4, 3); +------------------------+ |greatest(10, 9, 2, 4, 3)| +------------------------+ | 10| +------------------------+ -- hex SELECT hex(17); +-------+ |hex(17)| +-------+ | 11| +-------+ SELECT hex('SQL'); +------------------+ | hex(SQL)| +------------------+ |53514C| +------------------+ -- hypot SELECT hypot(3, 4); +-----------+ |HYPOT(3, 4)| +-----------+ | 5.0| +-----------+ -- least SELECT least(10, 9, 2, 4, 3); +---------------------+ |least(10, 9, 2, 4, 3)| +---------------------+ | 2| +---------------------+ -- ln SELECT ln(1); +-----+ |ln(1)| +-----+ | 0.0| +-----+ -- log SELECT log(10, 100); +------------+ |LOG(10, 100)| +------------+ | 2.0| +------------+ -- log10 SELECT log10(10); +---------+ |LOG10(10)| +---------+ | 1.0| +---------+ -- log1p SELECT log1p(0); +--------+ |LOG1P(0)| +--------+ | 0.0| +--------+ -- log2 SELECT log2(2); +-------+ |LOG2(2)| +-------+ | 1.0| +-------+ -- mod SELECT 2 % 1.8; +---------+ |(2 % 1.8)| +---------+ | 0.2| +---------+ SELECT MOD(2, 1.8); +-----------+ |mod(2, 1.8)| +-----------+ | 0.2| +-----------+ -- negative SELECT negative(1); +-----------+ |negative(1)| +-----------+ | -1| +-----------+ -- pi SELECT pi(); +-----------------+ | PI()| +-----------------+ |3.141592653589793| +-----------------+ -- pmod SELECT pmod(10, 3); +-----------+ |pmod(10, 3)| +-----------+ | 1| +-----------+ SELECT pmod(-10, 3); +------------+ |pmod(-10, 3)| +------------+ | 2| +------------+ -- positive SELECT positive(1); +-----+ |(+ 1)| +-----+ | 1| +-----+ -- pow SELECT pow(2, 3); +---------+ |pow(2, 3)| +---------+ | 8.0| +---------+ -- power SELECT power(2, 3); +-----------+ |POWER(2, 3)| +-----------+ | 8.0| +-----------+ -- radians SELECT radians(180); +-----------------+ | RADIANS(180)| +-----------------+ |3.141592653589793| +-----------------+ -- rand SELECT rand(); +------------------+ | rand()| +------------------+ |0.7211420708112387| +------------------+ SELECT rand(0); +------------------+ | rand(0)| +------------------+ |0.7604953758285915| +------------------+ SELECT rand(null); +------------------+ | rand(NULL)| +------------------+ |0.7604953758285915| +------------------+ -- randn SELECT randn(); +-------------------+ | randn()| +-------------------+ |-0.8175603217732732| +-------------------+ SELECT randn(0); +------------------+ | randn(0)| +------------------+ |1.6034991609278433| +------------------+ SELECT randn(null); +------------------+ | randn(NULL)| +------------------+ |1.6034991609278433| +------------------+ -- random SELECT random(); +-----------------+ | rand()| +-----------------+ |0.394205008255365| +-----------------+ SELECT random(0); +------------------+ | rand(0)| +------------------+ |0.7604953758285915| +------------------+ SELECT random(null); +------------------+ | rand(NULL)| +------------------+ |0.7604953758285915| +------------------+ -- rint SELECT rint(12.3456); +-------------+ |rint(12.3456)| +-------------+ | 12.0| +-------------+ -- round SELECT round(2.5, 0); +-------------+ |round(2.5, 0)| +-------------+ | 3| +-------------+ -- sec SELECT sec(0); +------+ |SEC(0)| +------+ | 1.0| +------+ -- shiftleft SELECT shiftleft(2, 1); +---------------+ |shiftleft(2, 1)| +---------------+ | 4| +---------------+ -- sign SELECT sign(40); +--------+ |sign(40)| +--------+ | 1.0| +--------+ SELECT sign(INTERVAL -'100' YEAR); +--------------------------+ |sign(INTERVAL '-100' YEAR)| +--------------------------+ | -1.0| +--------------------------+ -- signum SELECT signum(40); +----------+ |SIGNUM(40)| +----------+ | 1.0| +----------+ SELECT signum(INTERVAL -'100' YEAR); +----------------------------+ |SIGNUM(INTERVAL '-100' YEAR)| +----------------------------+ | -1.0| +----------------------------+ -- sin SELECT sin(0); +------+ |SIN(0)| +------+ | 0.0| +------+ -- sinh SELECT sinh(0); +-------+ |SINH(0)| +-------+ | 0.0| +-------+ -- sqrt SELECT sqrt(4); +-------+ |SQRT(4)| +-------+ | 2.0| +-------+ -- tan SELECT tan(0); +------+ |TAN(0)| +------+ | 0.0| +------+ -- tanh SELECT tanh(0); +-------+ |TANH(0)| +-------+ | 0.0| +-------+ -- try_add SELECT try_add(1, 2); +-------------+ |try_add(1, 2)| +-------------+ | 3| +-------------+ SELECT try_add(2147483647, 1); +----------------------+ |try_add(2147483647, 1)| +----------------------+ | NULL| +----------------------+ SELECT try_add(date'2021-01-01', 1); +-----------------------------+ |try_add(DATE '2021-01-01', 1)| +-----------------------------+ | 2021-01-02| +-----------------------------+ SELECT try_add(date'2021-01-01', interval 1 year); +---------------------------------------------+ |try_add(DATE '2021-01-01', INTERVAL '1' YEAR)| +---------------------------------------------+ | 2022-01-01| +---------------------------------------------+ SELECT try_add(timestamp'2021-01-01 00:00:00', interval 1 day); +----------------------------------------------------------+ |try_add(TIMESTAMP '2021-01-01 00:00:00', INTERVAL '1' DAY)| +----------------------------------------------------------+ | 2021-01-02 00:00:00| +----------------------------------------------------------+ SELECT try_add(interval 1 year, interval 2 year); +---------------------------------------------+ |try_add(INTERVAL '1' YEAR, INTERVAL '2' YEAR)| +---------------------------------------------+ | INTERVAL '3' YEAR| +---------------------------------------------+ -- try_divide SELECT try_divide(3, 2); +----------------+ |try_divide(3, 2)| +----------------+ | 1.5| +----------------+ SELECT try_divide(2L, 2L); +----------------+ |try_divide(2, 2)| +----------------+ | 1.0| +----------------+ SELECT try_divide(1, 0); +----------------+ |try_divide(1, 0)| +----------------+ | NULL| +----------------+ SELECT try_divide(interval 2 month, 2); +---------------------------------+ |try_divide(INTERVAL '2' MONTH, 2)| +---------------------------------+ | INTERVAL '0-1' YE...| +---------------------------------+ SELECT try_divide(interval 2 month, 0); +---------------------------------+ |try_divide(INTERVAL '2' MONTH, 0)| +---------------------------------+ | NULL| +---------------------------------+ -- try_multiply SELECT try_multiply(2, 3); +------------------+ |try_multiply(2, 3)| +------------------+ | 6| +------------------+ SELECT try_multiply(-2147483648, 10); +-----------------------------+ |try_multiply(-2147483648, 10)| +-----------------------------+ | NULL| +-----------------------------+ SELECT try_multiply(interval 2 year, 3); +----------------------------------+ |try_multiply(INTERVAL '2' YEAR, 3)| +----------------------------------+ | INTERVAL '6-0' YE...| +----------------------------------+ -- try_subtract SELECT try_subtract(2, 1); +------------------+ |try_subtract(2, 1)| +------------------+ | 1| +------------------+ SELECT try_subtract(-2147483648, 1); +----------------------------+ |try_subtract(-2147483648, 1)| +----------------------------+ | NULL| +----------------------------+ SELECT try_subtract(date'2021-01-02', 1); +----------------------------------+ |try_subtract(DATE '2021-01-02', 1)| +----------------------------------+ | 2021-01-01| +----------------------------------+ SELECT try_subtract(date'2021-01-01', interval 1 year); +--------------------------------------------------+ |try_subtract(DATE '2021-01-01', INTERVAL '1' YEAR)| +--------------------------------------------------+ | 2020-01-01| +--------------------------------------------------+ SELECT try_subtract(timestamp'2021-01-02 00:00:00', interval 1 day); +---------------------------------------------------------------+ |try_subtract(TIMESTAMP '2021-01-02 00:00:00', INTERVAL '1' DAY)| +---------------------------------------------------------------+ | 2021-01-01 00:00:00| +---------------------------------------------------------------+ SELECT try_subtract(interval 2 year, interval 1 year); +--------------------------------------------------+ |try_subtract(INTERVAL '2' YEAR, INTERVAL '1' YEAR)| +--------------------------------------------------+ | INTERVAL '1' YEAR| +--------------------------------------------------+ -- unhex SELECT decode(unhex('53514C'), 'UTF-8'); +----------------------------------------+ |decode(unhex(53514C), UTF-8)| +----------------------------------------+ | SQL| +----------------------------------------+ -- width_bucket SELECT width_bucket(5.3, 0.2, 10.6, 5); +-------------------------------+ |width_bucket(5.3, 0.2, 10.6, 5)| +-------------------------------+ | 3| +-------------------------------+ SELECT width_bucket(-2.1, 1.3, 3.4, 3); +-------------------------------+ |width_bucket(-2.1, 1.3, 3.4, 3)| +-------------------------------+ | 0| +-------------------------------+ SELECT width_bucket(8.1, 0.0, 5.7, 4); +------------------------------+ |width_bucket(8.1, 0.0, 5.7, 4)| +------------------------------+ | 5| +------------------------------+ SELECT width_bucket(-0.9, 5.2, 0.5, 2); +-------------------------------+ |width_bucket(-0.9, 5.2, 0.5, 2)| +-------------------------------+ | 3| +-------------------------------+ SELECT width_bucket(INTERVAL '0' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10); +--------------------------------------------------------------------------+ |width_bucket(INTERVAL '0' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10)| +--------------------------------------------------------------------------+ | 1| +--------------------------------------------------------------------------+ SELECT width_bucket(INTERVAL '1' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10); +--------------------------------------------------------------------------+ |width_bucket(INTERVAL '1' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10)| +--------------------------------------------------------------------------+ | 2| +--------------------------------------------------------------------------+ SELECT width_bucket(INTERVAL '0' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10); +-----------------------------------------------------------------------+ |width_bucket(INTERVAL '0' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10)| +-----------------------------------------------------------------------+ | 1| +-----------------------------------------------------------------------+ SELECT width_bucket(INTERVAL '1' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10); +-----------------------------------------------------------------------+ |width_bucket(INTERVAL '1' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10)| +-----------------------------------------------------------------------+ | 2| +-----------------------------------------------------------------------+ ``` #### Funzioni del generatore **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano queste funzioni SQL, consulta[Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql). **** | Funzione | Description | | --- | --- | | esplodere (expr) | Separa gli elementi dell'array `expr` in più righe o gli elementi della mappa `expr` in più righe e colonne. Se non diversamente specificato, utilizza il nome di colonna predefinito `col` per gli elementi dell'array o `key` e `value` per gli elementi della mappa. | | explode\$1outer (expr) | Separa gli elementi dell'array `expr` in più righe o gli elementi della mappa `expr` in più righe e colonne. Se non diversamente specificato, utilizza il nome di colonna predefinito `col` per gli elementi dell'array o `key` e `value` per gli elementi della mappa. | | in linea (expr) | Esplode una serie di strutture in una tabella. Utilizza i nomi di colonna col1, col2, ecc. per impostazione predefinita, se non diversamente specificato. | | inline\$1outer (expr) | Esplode una matrice di strutture in una tabella. Utilizza i nomi di colonna col1, col2, ecc. per impostazione predefinita, se non diversamente specificato. | | posexplode (expr) | Separa gli elementi dell'array `expr` in più righe con posizioni o gli elementi della mappa `expr` in più righe e colonne con posizioni. Se non diversamente specificato, utilizza il nome di colonna `pos` per la posizione, `col` per gli elementi dell'array o `key` e `value` per gli elementi della mappa. | | posexplode\$1outer (expr) | Separa gli elementi dell'array `expr` in più righe con posizioni o gli elementi della mappa `expr` in più righe e colonne con posizioni. Se non diversamente specificato, utilizza il nome di colonna `pos` per la posizione, `col` per gli elementi dell'array o `key` e `value` per gli elementi della mappa. | | pila (n, expr1,..., exprk) | Separa `expr1`,..., `exprk` in `n` righe. Utilizza i nomi di colonna col0, col1, ecc. per impostazione predefinita, se non diversamente specificato. | **Esempi** ``` -- explode SELECT explode(array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ SELECT explode(collection => array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ SELECT * FROM explode(collection => array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ -- explode_outer SELECT explode_outer(array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ SELECT explode_outer(collection => array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ SELECT * FROM explode_outer(collection => array(10, 20)); +---+ |col| +---+ | 10| | 20| +---+ -- inline SELECT inline(array(struct(1, 'a'), struct(2, 'b'))); +----+----+ |col1|col2| +----+----+ | 1| a| | 2| b| +----+----+ -- inline_outer SELECT inline_outer(array(struct(1, 'a'), struct(2, 'b'))); +----+----+ |col1|col2| +----+----+ | 1| a| | 2| b| +----+----+ -- posexplode SELECT posexplode(array(10,20)); +---+---+ |pos|col| +---+---+ | 0| 10| | 1| 20| +---+---+ SELECT * FROM posexplode(array(10,20)); +---+---+ |pos|col| +---+---+ | 0| 10| | 1| 20| +---+---+ -- posexplode_outer SELECT posexplode_outer(array(10,20)); +---+---+ |pos|col| +---+---+ | 0| 10| | 1| 20| +---+---+ SELECT * FROM posexplode_outer(array(10,20)); +---+---+ |pos|col| +---+---+ | 0| 10| | 1| 20| +---+---+ -- stack SELECT stack(2, 1, 2, 3); +----+----+ |col0|col1| +----+----+ | 1| 2| | 3|NULL| +----+----+ ``` #### Clausola SELECT **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) OpenSearch SQL supporta un'`SELECT`istruzione utilizzata per recuperare i set di risultati da una o più tabelle. La sezione seguente descrive la sintassi generale delle query e i diversi costrutti di una query. **Sintassi** ``` select_statement [ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select_statement, ... ] [ ORDER BY { expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] } ] [ SORT BY { expression [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [ , ... ] } ] [ WINDOW { named_window [ , WINDOW named_window, ... ] } ] [ LIMIT { ALL | expression } ] ``` While `select_statement` è definito come: ``` SELECT [ ALL | DISTINCT ] { [ [ named_expression ] [ , ... ] ] } FROM { from_item [ , ... ] } [ PIVOT clause ] [ UNPIVOT clause ] [ LATERAL VIEW clause ] [ ... ] [ WHERE boolean_expression ] [ GROUP BY expression [ , ... ] ] [ HAVING boolean_expression ] ``` **Parametri** + **TUTTO** Seleziona tutte le righe corrispondenti dalla relazione ed è abilitata per impostazione predefinita. + **DISTINTO** Seleziona tutte le righe corrispondenti dalla relazione dopo aver rimosso i duplicati nei risultati. + **named\$1expression** Un'espressione con un nome assegnato. In generale, denota un'espressione di colonna. Sintassi: `expression [[AS] alias]` + **from\$1item** Relazione tra tabelle Relazione di unione Relazione pivot Relazione Unpivot Funzione Table-value Tabella in linea `[ LATERAL ] ( Subquery )` + **PERNO** La `PIVOT` clausola viene utilizzata per la prospettiva dei dati. È possibile ottenere i valori aggregati in base al valore di colonna specifico. + **UNPIVOT** La `UNPIVOT` clausola trasforma le colonne in righe. È l'opposto di`PIVOT`, ad eccezione dell'aggregazione di valori. + **VISTA LATERALE** La `LATERAL VIEW` clausola viene utilizzata insieme a funzioni generatrici come`EXPLODE`, che genereranno una tabella virtuale contenente una o più righe. `LATERAL VIEW`applicherà le righe a ciascuna riga di output originale. + **DOVE** Filtra il risultato della `FROM` clausola in base ai predicati forniti. + **RAGGRUPPA PER** Speciifica le espressioni utilizzate per raggruppare le righe. Viene utilizzato insieme alle funzioni di aggregazione (`MIN`,,, `MAX` `COUNT` `SUM``AVG`, e così via) per raggruppare le righe in base alle espressioni di raggruppamento e ai valori aggregati di ciascun gruppo. Quando una `FILTER` clausola è associata a una funzione aggregata, solo le righe corrispondenti vengono passate a quella funzione. + **AVENDO** Speciifica i predicati in base ai quali `GROUP BY` vengono filtrate le righe prodotte da. La `HAVING` clausola viene utilizzata per filtrare le righe dopo l'esecuzione del raggruppamento. Se `HAVING` viene specificato senza`GROUP BY`, indica un'espressione `GROUP BY` senza raggruppamento (aggregato globale). + **ORDINA PER** Speciifica l'ordinamento delle righe del set completo di risultati della query. Le righe di output sono ordinate tra le partizioni. Questo parametro si esclude a vicenda con `SORT BY` e `DISTRIBUTE BY` e non può essere specificato insieme. + **ORDINA PER** Speciifica l'ordine in base al quale le righe vengono ordinate all'interno di ciascuna partizione. Questo parametro si esclude a vicenda `ORDER BY` e non può essere specificato insieme. + **LIMITE** Speciifica il numero massimo di righe che possono essere restituite da un'istruzione o una sottoquery. Questa clausola viene utilizzata principalmente in combinazione con per produrre un risultato `ORDER BY` deterministico. + **espressione booleana** Specifica qualsiasi espressione che restituisce un tipo di risultato booleano. Due o più espressioni possono essere combinate insieme utilizzando gli operatori logici (,). `AND` `OR` + **espressione** Speciifica una combinazione di uno o più valori, operatori e funzioni SQL che restituisce un valore. + **finestra\$1denominata** Specificate gli alias per una o più specifiche della finestra di origine. È possibile fare riferimento alle specifiche della finestra di origine nelle definizioni della finestra dell'interrogazione. #### Clausola WHERE **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) La `WHERE` clausola viene utilizzata per limitare i risultati della `FROM` clausola di una query o di una sottoquery in base alla condizione specificata. **Sintassi** ``` WHERE boolean_expression ``` **Parametri** + **espressione booleana** Specifica qualsiasi espressione che restituisce un risultato di tipo booleano. Due o più espressioni possono essere combinate insieme utilizzando gli operatori logici (,). `AND` `OR` **Esempi** ``` CREATE TABLE person (id INT, name STRING, age INT); INSERT INTO person VALUES (100, 'John', 30), (200, 'Mary', NULL), (300, 'Mike', 80), (400, 'Dan', 50); -- Comparison operator in `WHERE` clause. SELECT * FROM person WHERE id > 200 ORDER BY id; +---+----+---+ | id|name|age| +---+----+---+ |300|Mike| 80| |400| Dan| 50| +---+----+---+ -- Comparison and logical operators in `WHERE` clause. SELECT * FROM person WHERE id = 200 OR id = 300 ORDER BY id; +---+----+----+ | id|name| age| +---+----+----+ |200|Mary|null| |300|Mike| 80| +---+----+----+ -- IS NULL expression in `WHERE` clause. SELECT * FROM person WHERE id > 300 OR age IS NULL ORDER BY id; +---+----+----+ | id|name| age| +---+----+----+ |200|Mary|null| |400| Dan| 50| +---+----+----+ -- Function expression in `WHERE` clause. SELECT * FROM person WHERE length(name) > 3 ORDER BY id; +---+----+----+ | id|name| age| +---+----+----+ |100|John| 30| |200|Mary|null| |300|Mike| 80| +---+----+----+ -- `BETWEEN` expression in `WHERE` clause. SELECT * FROM person WHERE id BETWEEN 200 AND 300 ORDER BY id; +---+----+----+ | id|name| age| +---+----+----+ |200|Mary|null| |300|Mike| 80| +---+----+----+ -- Scalar Subquery in `WHERE` clause. SELECT * FROM person WHERE age > (SELECT avg(age) FROM person); +---+----+---+ | id|name|age| +---+----+---+ |300|Mike| 80| +---+----+---+ -- Correlated Subquery in `WHERE` clause. SELECT id FROM person WHERE exists (SELECT id FROM person where id = 200); +---+----+----+ |id |name|age | +---+----+----+ |200|Mary|null| +---+----+----+ ``` #### Clausola GROUP BY **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi[Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql). La `GROUP BY` clausola viene utilizzata per raggruppare le righe in base a un insieme di espressioni di raggruppamento specificate e calcolare le aggregazioni sul gruppo di righe in base a una o più funzioni di aggregazione specificate. Il sistema esegue anche più aggregazioni per lo stesso record di input impostato tramite clausole,. `GROUPING SETS` `CUBE` `ROLLUP` Le espressioni di raggruppamento e le aggregazioni avanzate possono essere mescolate nella clausola e annidate in una `GROUP BY` clausola. `GROUPING SETS ` Vedi maggiori dettagli nella sezione. `Mixed/Nested Grouping Analytics ` Quando una `FILTER` clausola è associata a una funzione aggregata, solo le righe corrispondenti vengono passate a quella funzione. **Sintassi** ``` GROUP BY group_expression [ , group_expression [ , ... ] ] [ WITH { ROLLUP | CUBE } ] GROUP BY { group_expression | { ROLLUP | CUBE | GROUPING SETS } (grouping_set [ , ...]) } [ , ... ] ``` Mentre le funzioni aggregate sono definite come: ``` aggregate_name ( [ DISTINCT ] expression [ , ... ] ) [ FILTER ( WHERE boolean_expression ) ] ``` **Parametri** + **espressione di gruppo** Speciifica i criteri in base ai quali le righe vengono raggruppate. Il raggruppamento delle righe viene eseguito in base ai valori dei risultati delle espressioni di raggruppamento. Un'espressione di raggruppamento può essere simile al nome di una colonna`GROUP BY a`, alla posizione di una colonna o a un'espressione simile`GROUP BY 0`. `GROUP BY a + b` + **grouping\$1set** Un set di raggruppamento è specificato da zero o più espressioni separate da virgole tra parentesi. Quando il set di raggruppamento contiene un solo elemento, le parentesi possono essere omesse. Ad esempio, `GROUPING SETS ((a), (b))` è equivalente a `GROUPING SETS (a, b)`. Sintassi: `{ ( [ expression [ , ... ] ] ) | expression }` + **SET DI RAGGRUPPAMENTO** Raggruppa le righe per ogni set di raggruppamento specificato dopo. `GROUPING SETS` Ad esempio, `GROUP BY GROUPING SETS ((warehouse), (product))` è semanticamente equivalente all'unione dei risultati di e. `GROUP BY warehouse` `GROUP BY product` Questa clausola è un'abbreviazione di UNION ALL in cui ogni parte dell'`UNION ALL`operatore esegue l'aggregazione di ogni set di raggruppamento specificato nella clausola. `GROUPING SETS` Analogamente, `GROUP BY GROUPING SETS ((warehouse, product), (product), ())` è semanticamente equivalente all'unione dei risultati di un aggregato globale. `GROUP BY warehouse, product, GROUP BY product` + **ROLLUP** Speciifica più livelli di aggregazioni in una singola istruzione. Questa clausola viene utilizzata per calcolare aggregazioni basate su più set di raggruppamento. `ROLLUP`è un'abbreviazione di. `GROUPING SETS` Ad esempio, `GROUP BY warehouse, product WITH ROLLUP or GROUP BY ROLLUP(warehouse, product)` è uguale a `GROUP BY GROUPING SETS((warehouse, product), (warehouse), ())`. `GROUP BY ROLLUP(warehouse, product, (warehouse, location))` equivale a `GROUP BY GROUPING SETS((warehouse, product, location), (warehouse, product), (warehouse), ())`. Gli N elementi di una specifica ROLLUP danno come risultato N\$11 GROUPING SETS. + **CUBE** La clausola CUBE viene utilizzata per eseguire aggregazioni basate sulla combinazione di colonne di raggruppamento specificate nella clausola GROUP BY. CUBE è l'abbreviazione di GROUPING SETS. Ad esempio, `GROUP BY warehouse, product WITH CUBE or GROUP BY CUBE(warehouse, product)` è uguale a `GROUP BY GROUPING SETS((warehouse, product), (warehouse), (product), ())`. `GROUP BY CUBE(warehouse, product, (warehouse, location))` equivale a `GROUP BY GROUPING SETS((warehouse, product, location), (warehouse, product), (warehouse, location), (product, warehouse, location), (warehouse), (product), (warehouse, product), ())`. Gli N elementi di una `CUBE` specifica danno come risultato 2^N. `GROUPING SETS` + **Analisi di raggruppamento misto/annidato** Una `GROUP BY` clausola può includere più espressioni di gruppo e più espressioni. `CUBE|ROLLUP|GROUPING SETS` `GROUPING SETS`può anche avere `CUBE|ROLLUP|GROUPING SETS` clausole annidate, ad esempio,. `GROUPING SETS(ROLLUP(warehouse, location)` `CUBE(warehouse, location))` `GROUPING SETS(warehouse, GROUPING SETS(location, GROUPING SETS(ROLLUP(warehouse, location),` `CUBE(warehouse, location))))` `CUBE|ROLLUP`è solo uno zucchero di sintassi per. `GROUPING SETS` Consulta le sezioni precedenti per sapere come `CUBE|ROLLUP` tradurre in`GROUPING SETS`. `group_expression`può essere trattato come un singolo gruppo `GROUPING SETS` in questo contesto. Per i multipli `GROUPING SETS` della `GROUP BY` clausola, ne generiamo uno singolo `GROUPING SETS` facendo un prodotto incrociato dell'originale. `GROUPING SETS` Poiché è inserito `GROUPING SETS` nella `GROUPING SETS` clausola, prendiamo semplicemente i suoi set di raggruppamento e li eliminiamo. Ad esempio, `GROUP BY warehouse, GROUPING SETS((product), ()), GROUPING SETS((location, size), (location), (size), ()) and GROUP BY warehouse, ROLLUP(product), CUBE(location, size)` è uguale a `GROUP BY GROUPING SETS( (warehouse, product, location, size), (warehouse, product, location), (warehouse, product, size), (warehouse, product), (warehouse, location, size), (warehouse, location), (warehouse, size), (warehouse))`. `GROUP BY GROUPING SETS(GROUPING SETS(warehouse), GROUPING SETS((warehouse, product)))` equivale a `GROUP BY GROUPING SETS((warehouse), (warehouse, product))`. + **nome\$1aggregato** Specificate il nome di una funzione aggregata (`MIN`,,, `MAX` `COUNT` `SUM``AVG`, e così via). + **DISTINTO** Rimuove i duplicati nelle righe di input prima che vengano passati alle funzioni aggregate. + **FILTRO** Filtra le righe di input per le quali la `WHERE` clausola `boolean_expression` in the restituisce true vengono passate alla funzione di aggregazione; le altre righe vengono scartate. **Esempi** ``` CREATE TABLE dealer (id INT, city STRING, car_model STRING, quantity INT); INSERT INTO dealer VALUES (100, 'Fremont', 'Honda Civic', 10), (100, 'Fremont', 'Honda Accord', 15), (100, 'Fremont', 'Honda CRV', 7), (200, 'Dublin', 'Honda Civic', 20), (200, 'Dublin', 'Honda Accord', 10), (200, 'Dublin', 'Honda CRV', 3), (300, 'San Jose', 'Honda Civic', 5), (300, 'San Jose', 'Honda Accord', 8); -- Sum of quantity per dealership. Group by `id`. SELECT id, sum(quantity) FROM dealer GROUP BY id ORDER BY id; +---+-------------+ | id|sum(quantity)| +---+-------------+ |100| 32| |200| 33| |300| 13| +---+-------------+ -- Use column position in GROUP by clause. SELECT id, sum(quantity) FROM dealer GROUP BY 1 ORDER BY 1; +---+-------------+ | id|sum(quantity)| +---+-------------+ |100| 32| |200| 33| |300| 13| +---+-------------+ -- Multiple aggregations. -- 1. Sum of quantity per dealership. -- 2. Max quantity per dealership. SELECT id, sum(quantity) AS sum, max(quantity) AS max FROM dealer GROUP BY id ORDER BY id; +---+---+---+ | id|sum|max| +---+---+---+ |100| 32| 15| |200| 33| 20| |300| 13| 8| +---+---+---+ -- Count the number of distinct dealer cities per car_model. SELECT car_model, count(DISTINCT city) AS count FROM dealer GROUP BY car_model; +------------+-----+ | car_model|count| +------------+-----+ | Honda Civic| 3| | Honda CRV| 2| |Honda Accord| 3| +------------+-----+ -- Sum of only 'Honda Civic' and 'Honda CRV' quantities per dealership. SELECT id, sum(quantity) FILTER ( WHERE car_model IN ('Honda Civic', 'Honda CRV') ) AS `sum(quantity)` FROM dealer GROUP BY id ORDER BY id; +---+-------------+ | id|sum(quantity)| +---+-------------+ |100| 17| |200| 23| |300| 5| +---+-------------+ -- Aggregations using multiple sets of grouping columns in a single statement. -- Following performs aggregations based on four sets of grouping columns. -- 1. city, car_model -- 2. city -- 3. car_model -- 4. Empty grouping set. Returns quantities for all city and car models. SELECT city, car_model, sum(quantity) AS sum FROM dealer GROUP BY GROUPING SETS ((city, car_model), (city), (car_model), ()) ORDER BY city; +---------+------------+---+ | city| car_model|sum| +---------+------------+---+ | null| null| 78| | null| HondaAccord| 33| | null| HondaCRV| 10| | null| HondaCivic| 35| | Dublin| null| 33| | Dublin| HondaAccord| 10| | Dublin| HondaCRV| 3| | Dublin| HondaCivic| 20| | Fremont| null| 32| | Fremont| HondaAccord| 15| | Fremont| HondaCRV| 7| | Fremont| HondaCivic| 10| | San Jose| null| 13| | San Jose| HondaAccord| 8| | San Jose| HondaCivic| 5| +---------+------------+---+ -- Group by processing with `ROLLUP` clause. -- Equivalent GROUP BY GROUPING SETS ((city, car_model), (city), ()) SELECT city, car_model, sum(quantity) AS sum FROM dealer GROUP BY city, car_model WITH ROLLUP ORDER BY city, car_model; +---------+------------+---+ | city| car_model|sum| +---------+------------+---+ | null| null| 78| | Dublin| null| 33| | Dublin| HondaAccord| 10| | Dublin| HondaCRV| 3| | Dublin| HondaCivic| 20| | Fremont| null| 32| | Fremont| HondaAccord| 15| | Fremont| HondaCRV| 7| | Fremont| HondaCivic| 10| | San Jose| null| 13| | San Jose| HondaAccord| 8| | San Jose| HondaCivic| 5| +---------+------------+---+ -- Group by processing with `CUBE` clause. -- Equivalent GROUP BY GROUPING SETS ((city, car_model), (city), (car_model), ()) SELECT city, car_model, sum(quantity) AS sum FROM dealer GROUP BY city, car_model WITH CUBE ORDER BY city, car_model; +---------+------------+---+ | city| car_model|sum| +---------+------------+---+ | null| null| 78| | null| HondaAccord| 33| | null| HondaCRV| 10| | null| HondaCivic| 35| | Dublin| null| 33| | Dublin| HondaAccord| 10| | Dublin| HondaCRV| 3| | Dublin| HondaCivic| 20| | Fremont| null| 32| | Fremont| HondaAccord| 15| | Fremont| HondaCRV| 7| | Fremont| HondaCivic| 10| | San Jose| null| 13| | San Jose| HondaAccord| 8| | San Jose| HondaCivic| 5| +---------+------------+---+ --Prepare data for ignore nulls example CREATE TABLE person (id INT, name STRING, age INT); INSERT INTO person VALUES (100, 'Mary', NULL), (200, 'John', 30), (300, 'Mike', 80), (400, 'Dan', 50); --Select the first row in column age SELECT FIRST(age) FROM person; +--------------------+ | first(age, false) | +--------------------+ | NULL | +--------------------+ --Get the first row in column `age` ignore nulls,last row in column `id` and sum of column `id`. SELECT FIRST(age IGNORE NULLS), LAST(id), SUM(id) FROM person; +-------------------+------------------+----------+ | first(age, true) | last(id, false) | sum(id) | +-------------------+------------------+----------+ | 30 | 400 | 1000 | +-------------------+------------------+----------+ ``` #### Clausola HAVING **Nota** Per vedere quali integrazioni di origini AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) La `HAVING` clausola viene utilizzata per filtrare i risultati prodotti da `GROUP BY` in base alla condizione specificata. Viene spesso utilizzata insieme a una `GROUP BY` clausola. **Sintassi** ``` HAVING boolean_expression ``` **Parametri** + **espressione\$1booleana** Specifica qualsiasi espressione che restituisce un tipo di risultato booleano. Due o più espressioni possono essere combinate insieme utilizzando gli operatori logici (,). `AND` `OR` **Nota** Le espressioni specificate nella `HAVING` clausola possono fare riferimento solo a: 1. Costanti 1. Espressioni che compaiono in `GROUP BY` 1. Funzioni di aggregazione **Esempi** ``` CREATE TABLE dealer (id INT, city STRING, car_model STRING, quantity INT); INSERT INTO dealer VALUES (100, 'Fremont', 'Honda Civic', 10), (100, 'Fremont', 'Honda Accord', 15), (100, 'Fremont', 'Honda CRV', 7), (200, 'Dublin', 'Honda Civic', 20), (200, 'Dublin', 'Honda Accord', 10), (200, 'Dublin', 'Honda CRV', 3), (300, 'San Jose', 'Honda Civic', 5), (300, 'San Jose', 'Honda Accord', 8); -- `HAVING` clause referring to column in `GROUP BY`. SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING city = 'Fremont'; +-------+---+ | city|sum| +-------+---+ |Fremont| 32| +-------+---+ -- `HAVING` clause referring to aggregate function. SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING sum(quantity) > 15; +-------+---+ | city|sum| +-------+---+ | Dublin| 33| |Fremont| 32| +-------+---+ -- `HAVING` clause referring to aggregate function by its alias. SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING sum > 15; +-------+---+ | city|sum| +-------+---+ | Dublin| 33| |Fremont| 32| +-------+---+ -- `HAVING` clause referring to a different aggregate function than what is present in -- `SELECT` list. SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING max(quantity) > 15; +------+---+ | city|sum| +------+---+ |Dublin| 33| +------+---+ -- `HAVING` clause referring to constant expression. SELECT city, sum(quantity) AS sum FROM dealer GROUP BY city HAVING 1 > 0 ORDER BY city; +--------+---+ | city|sum| +--------+---+ | Dublin| 33| | Fremont| 32| |San Jose| 13| +--------+---+ -- `HAVING` clause without a `GROUP BY` clause. SELECT sum(quantity) AS sum FROM dealer HAVING sum(quantity) > 10; +---+ |sum| +---+ | 78| +---+ ``` #### Clausola ORDER BY **Nota** Per vedere quali integrazioni di origini AWS dati supportano questo comando SQL, vedi[Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql). La `ORDER BY` clausola viene utilizzata per restituire le righe dei risultati in modo ordinato nell'ordine specificato dall'utente. A differenza della clausola SORT BY, questa clausola garantisce un ordine totale nell'output. **Sintassi** ``` ORDER BY { expression [ sort_direction | nulls_sort_order ] [ , ... ] } ``` **Parametri** + **ORDINA PER** Specifica un elenco di espressioni separate da virgole insieme a parametri opzionali `sort_direction` e `nulls_sort_order` che vengono utilizzate per ordinare le righe. + **sort\$1direction** Facoltativamente specifica se ordinare le righe in ordine crescente o decrescente. I valori validi per la direzione di ordinamento sono per l'ordine crescente e `ASC` per il decrescente. `DESC` Se la direzione di ordinamento non è specificata in modo esplicito, per impostazione predefinita le righe vengono ordinate in modo crescente. Sintassi: `[ ASC | DESC ] ` + **nulls\$1sort\$1order** Specifica facoltativamente se vengono restituiti valori non NULL. `NULL` before/after Se null\$1sort\$1order non è specificato, ordina prima se l'ordinamento è e NULLS `NULLs` ordina per ultimo se l'ordinamento è`ASC`. `DESC` 1. Se `NULLS FIRST` è specificato, i valori NULL vengono restituiti per primi indipendentemente dal tipo di ordinamento. 2. Se `NULLS LAST` viene specificato, i valori NULL vengono restituiti per ultimi indipendentemente dal tipo di ordinamento. Sintassi: `[ NULLS { FIRST | LAST } ]` **Esempi** ``` CREATE TABLE person (id INT, name STRING, age INT); INSERT INTO person VALUES (100, 'John', 30), (200, 'Mary', NULL), (300, 'Mike', 80), (400, 'Jerry', NULL), (500, 'Dan', 50); -- Sort rows by age. By default rows are sorted in ascending manner with NULL FIRST. SELECT name, age FROM person ORDER BY age; +-----+----+ | name| age| +-----+----+ |Jerry|null| | Mary|null| | John| 30| | Dan| 50| | Mike| 80| +-----+----+ -- Sort rows in ascending manner keeping null values to be last. SELECT name, age FROM person ORDER BY age NULLS LAST; +-----+----+ | name| age| +-----+----+ | John| 30| | Dan| 50| | Mike| 80| | Mary|null| |Jerry|null| +-----+----+ -- Sort rows by age in descending manner, which defaults to NULL LAST. SELECT name, age FROM person ORDER BY age DESC; +-----+----+ | name| age| +-----+----+ | Mike| 80| | Dan| 50| | John| 30| |Jerry|null| | Mary|null| +-----+----+ -- Sort rows in ascending manner keeping null values to be first. SELECT name, age FROM person ORDER BY age DESC NULLS FIRST; +-----+----+ | name| age| +-----+----+ |Jerry|null| | Mary|null| | Mike| 80| | Dan| 50| | John| 30| +-----+----+ -- Sort rows based on more than one column with each column having different -- sort direction. SELECT * FROM person ORDER BY name ASC, age DESC; +---+-----+----+ | id| name| age| +---+-----+----+ |500| Dan| 50| |400|Jerry|null| |100| John| 30| |200| Mary|null| |300| Mike| 80| +---+-----+----+ ``` #### Clausola JOIN **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) Un join SQL viene utilizzato per combinare righe di due relazioni in base a criteri di unione. La sezione seguente descrive la sintassi generale del join e i diversi tipi di join insieme a esempi. **Sintassi** ``` relation INNER JOIN relation [ join_criteria ] ``` **Parametri** + **relazione** Specifica la relazione da unire. + **join\$1type** Specifica il tipo di join. Sintassi: `INNER | CROSS | LEFT OUTER` + **join\$1criteria** Speciifica come le righe di una relazione verranno combinate con le righe di un'altra relazione. Sintassi: `ON boolean_expression | USING ( column_name [ , ... ] ) ` + **espressione\$1booleana** Specifica un'espressione con un tipo restituito di tipo booleano. **Tipi di join** + **Inner Join** L'inner join deve essere specificato in modo esplicito. Seleziona le righe con valori corrispondenti in entrambe le relazioni. Sintassi: `relation INNER JOIN relation [ join_criteria ] ` + **Left Join** Un left join restituisce tutti i valori della relazione sinistra e i valori corrispondenti della relazione destra oppure aggiunge NULL se non c'è corrispondenza. Viene anche chiamato left outer join. Sintassi: `relation LEFT OUTER JOIN relation [ join_criteria ]` + **Cross Join** Un cross join restituisce il prodotto cartesiano di due relazioni. Sintassi: `relation CROSS JOIN relation [ join_criteria ]` **Esempi** ``` -- Use employee and department tables to demonstrate different type of joins. SELECT * FROM employee; +---+-----+------+ | id| name|deptno| +---+-----+------+ |105|Chloe| 5| |103| Paul| 3| |101| John| 1| |102| Lisa| 2| |104| Evan| 4| |106| Amy| 6| +---+-----+------+ SELECT * FROM department; +------+-----------+ |deptno| deptname| +------+-----------+ | 3|Engineering| | 2| Sales| | 1| Marketing| +------+-----------+ -- Use employee and department tables to demonstrate inner join. SELECT id, name, employee.deptno, deptname FROM employee INNER JOIN department ON employee.deptno = department.deptno; +---+-----+------+-----------| | id| name|deptno| deptname| +---+-----+------+-----------| |103| Paul| 3|Engineering| |101| John| 1| Marketing| |102| Lisa| 2| Sales| +---+-----+------+-----------| -- Use employee and department tables to demonstrate left join. SELECT id, name, employee.deptno, deptname FROM employee LEFT JOIN department ON employee.deptno = department.deptno; +---+-----+------+-----------| | id| name|deptno| deptname| +---+-----+------+-----------| |105|Chloe| 5| NULL| |103| Paul| 3|Engineering| |101| John| 1| Marketing| |102| Lisa| 2| Sales| |104| Evan| 4| NULL| |106| Amy| 6| NULL| +---+-----+------+-----------| -- Use employee and department tables to demonstrate cross join. SELECT id, name, employee.deptno, deptname FROM employee CROSS JOIN department; +---+-----+------+-----------| | id| name|deptno| deptname| +---+-----+------+-----------| |105|Chloe| 5|Engineering| |105|Chloe| 5| Marketing| |105|Chloe| 5| Sales| |103| Paul| 3|Engineering| |103| Paul| 3| Marketing| |103| Paul| 3| Sales| |101| John| 1|Engineering| |101| John| 1| Marketing| |101| John| 1| Sales| |102| Lisa| 2|Engineering| |102| Lisa| 2| Marketing| |102| Lisa| 2| Sales| |104| Evan| 4|Engineering| |104| Evan| 4| Marketing| |104| Evan| 4| Sales| |106| Amy| 4|Engineering| |106| Amy| 4| Marketing| |106| Amy| 4| Sales| +---+-----+------+-----------| ``` #### Clausola LIMIT **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) La `LIMIT` clausola viene utilizzata per limitare il numero di righe restituite dall'istruzione. `SELECT` In generale, questa clausola viene utilizzata insieme a per `ORDER BY` garantire che i risultati siano deterministici. **Sintassi** ``` LIMIT { ALL | integer_expression } ``` **Parametri** + **TUTTO** Se specificato, la query restituisce tutte le righe. In altre parole, non viene applicato alcun limite se viene specificata questa opzione. + **espressione intera** Specifica un'espressione pieghevole che restituisce un numero intero. **Esempi** ``` CREATE TABLE person (name STRING, age INT); INSERT INTO person VALUES ('Jane Doe', 25), ('Pat C', 18), ('Nikki W', 16), ('John D', 25), ('Juan L', 18), ('Jorge S', 16); -- Select the first two rows. SELECT name, age FROM person ORDER BY name LIMIT 2; +-------+---+ | name|age| +-------+---+ | Pat C| 18| |Jorge S| 16| +------+---+ -- Specifying ALL option on LIMIT returns all the rows. SELECT name, age FROM person ORDER BY name LIMIT ALL; +--------+---+ | name|age| +--------+---+ | Pat C| 18| | Jorge S| 16| | Juan L| 18| | John D| 25| | Nikki W| 16| |Jane Doe| 25| +--------+---+ -- A function expression as an input to LIMIT. SELECT name, age FROM person ORDER BY name LIMIT length('OPENSEARCH'); +-------+---+ | name|age| +-------+---+ | Pat C| 18| |Jorge S| 16| | Juan L| 18| | John D| 25| |Nikki W| 16| +-------+---+ ``` #### Clausola CASE **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) La `CASE` clausola utilizza una regola per restituire un risultato specifico in base alla condizione specificata, in modo simile alle istruzioni if/else in altri linguaggi di programmazione. **Sintassi** ``` CASE [ expression ] { WHEN boolean_expression THEN then_expression } [ ... ] [ ELSE else_expression ] END ``` **Parametri** + **espressione\$1booleana** Specifica qualsiasi espressione che restituisce un tipo di risultato booleano. Due o più espressioni possono essere combinate insieme utilizzando gli operatori logici (,). `AND` `OR` + **then\$1expression** Specifica l'espressione then in base alla condizione boolean\$1expression. `then_expression`e `else_expression` dovrebbero essere tutti dello stesso tipo o compatibili con un tipo comune. + **else\$1expression** Specifica l'espressione predefinita. `then_expression`e ` else_expression` devono essere tutti dello stesso tipo o compatibili con un tipo comune. **Esempi** ``` CREATE TABLE person (id INT, name STRING, age INT); INSERT INTO person VALUES (100, 'John', 30), (200, 'Mary', NULL), (300, 'Mike', 80), (400, 'Dan', 50); SELECT id, CASE WHEN id > 200 THEN 'bigger' ELSE 'small' END FROM person; +------+--------------------------------------------------+ | id | CASE WHEN (id > 200) THEN bigger ELSE small END | +------+--------------------------------------------------+ | 100 | small | | 200 | small | | 300 | bigger | | 400 | bigger | +------+--------------------------------------------------+ SELECT id, CASE id WHEN 100 then 'bigger' WHEN id > 300 THEN '300' ELSE 'small' END FROM person; +------+-----------------------------------------------------------------------------------------------+ | id | CASE WHEN (id = 100) THEN bigger WHEN (id = CAST((id > 300) AS INT)) THEN 300 ELSE small END | +------+-----------------------------------------------------------------------------------------------+ | 100 | bigger | | 200 | small | | 300 | small | | 400 | small | +------+-----------------------------------------------------------------------------------------------+ ``` #### Espressione di tabella comune **Nota** Per vedere quali integrazioni di origini AWS dati supportano questo comando SQL, vedi[Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql). Un'espressione di tabella comune (CTE) definisce un set di risultati temporaneo a cui un utente può fare riferimento, possibilmente più volte, nell'ambito di un'istruzione SQL. Un CTE viene utilizzato principalmente in una `SELECT` dichiarazione. **Sintassi** ``` WITH common_table_expression [ , ... ] ``` While `common_table_expression` è definito come: ``` Syntexpression_name [ ( column_name [ , ... ] ) ] [ AS ] ( query ) ``` **Parametri** + **nome\$1espressione** Specificate un nome per l'espressione della tabella comune. + **query** Una `SELECT` dichiarazione. **Esempi** ``` -- CTE with multiple column aliases WITH t(x, y) AS (SELECT 1, 2) SELECT * FROM t WHERE x = 1 AND y = 2; +---+---+ | x| y| +---+---+ | 1| 2| +---+---+ -- CTE in CTE definition WITH t AS ( WITH t2 AS (SELECT 1) SELECT * FROM t2 ) SELECT * FROM t; +---+ | 1| +---+ | 1| +---+ -- CTE in subquery SELECT max(c) FROM ( WITH t(c) AS (SELECT 1) SELECT * FROM t ); +------+ |max(c)| +------+ | 1| +------+ -- CTE in subquery expression SELECT ( WITH t AS (SELECT 1) SELECT * FROM t ); +----------------+ |scalarsubquery()| +----------------+ | 1| +----------------+ -- CTE in CREATE VIEW statement CREATE VIEW v AS WITH t(a, b, c, d) AS (SELECT 1, 2, 3, 4) SELECT * FROM t; SELECT * FROM v; +---+---+---+---+ | a| b| c| d| +---+---+---+---+ | 1| 2| 3| 4| +---+---+---+---+ ``` #### EXPLAIN **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi[Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql). L'`EXPLAIN`istruzione viene utilizzata per fornire piani logici/fisici per un'istruzione di input. Per impostazione predefinita, questa clausola fornisce informazioni solo su un piano fisico. **Sintassi** ``` EXPLAIN [ EXTENDED | CODEGEN | COST | FORMATTED ] statement ``` **Parametri** + **ESTESO** Genera piano logico analizzato, piano logico analizzato, piano logico ottimizzato e piano fisico. Il piano logico analizzato è un piano irrisolto estratto dalla query. I piani logici analizzati si trasformano e si traducono in oggetti completamente `unresolvedAttribute` tipizzati`unresolvedRelation`. Il piano logico ottimizzato si trasforma attraverso una serie di regole di ottimizzazione, dando origine al piano fisico. + **CODEGEN** Genera il codice per l'eventuale dichiarazione e un piano fisico. + **COSTO** Se le statistiche del nodo del piano sono disponibili, genera un piano logico e le statistiche. + **FORMATTATO** Genera due sezioni: uno schema fisico del piano e i dettagli del nodo. + **Istruzione** Specifica un'istruzione SQL da spiegare. **Esempi** ``` -- Default Output EXPLAIN select k, sum(v) from values (1, 2), (1, 3) t(k, v) group by k; +----------------------------------------------------+ | plan| +----------------------------------------------------+ | == Physical Plan == *(2) HashAggregate(keys=[k#33], functions=[sum(cast(v#34 as bigint))]) +- Exchange hashpartitioning(k#33, 200), true, [id=#59] +- *(1) HashAggregate(keys=[k#33], functions=[partial_sum(cast(v#34 as bigint))]) +- *(1) LocalTableScan [k#33, v#34] | +---------------------------------------------------- -- Using Extended EXPLAIN EXTENDED select k, sum(v) from values (1, 2), (1, 3) t(k, v) group by k; +----------------------------------------------------+ | plan| +----------------------------------------------------+ | == Parsed Logical Plan == 'Aggregate ['k], ['k, unresolvedalias('sum('v), None)] +- 'SubqueryAlias `t` +- 'UnresolvedInlineTable [k, v], [List(1, 2), List(1, 3)] == Analyzed Logical Plan == k: int, sum(v): bigint Aggregate [k#47], [k#47, sum(cast(v#48 as bigint)) AS sum(v)#50L] +- SubqueryAlias `t` +- LocalRelation [k#47, v#48] == Optimized Logical Plan == Aggregate [k#47], [k#47, sum(cast(v#48 as bigint)) AS sum(v)#50L] +- LocalRelation [k#47, v#48] == Physical Plan == *(2) HashAggregate(keys=[k#47], functions=[sum(cast(v#48 as bigint))], output=[k#47, sum(v)#50L]) +- Exchange hashpartitioning(k#47, 200), true, [id=#79] +- *(1) HashAggregate(keys=[k#47], functions=[partial_sum(cast(v#48 as bigint))], output=[k#47, sum#52L]) +- *(1) LocalTableScan [k#47, v#48] | +----------------------------------------------------+ -- Using Formatted EXPLAIN FORMATTED select k, sum(v) from values (1, 2), (1, 3) t(k, v) group by k; +----------------------------------------------------+ | plan| +----------------------------------------------------+ | == Physical Plan == * HashAggregate (4) +- Exchange (3) +- * HashAggregate (2) +- * LocalTableScan (1) (1) LocalTableScan [codegen id : 1] Output: [k#19, v#20] (2) HashAggregate [codegen id : 1] Input: [k#19, v#20] (3) Exchange Input: [k#19, sum#24L] (4) HashAggregate [codegen id : 2] Input: [k#19, sum#24L] | +----------------------------------------------------+ ``` #### Clausola LATERAL SUBQUERY **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) `LATERAL SUBQUERY`è una sottoquery preceduta dalla parola chiave. `LATERAL` Fornisce un modo per fare riferimento alle colonne della clausola precedente. `FROM` Senza la `LATERAL` parola chiave, le sottoquery possono fare riferimento solo alle colonne della query esterna, ma non alla clausola. `FROM` `LATERAL SUBQUERY`rende le interrogazioni complicate più semplici ed efficienti. **Sintassi** ``` [ LATERAL ] primary_relation [ join_relation ] ``` **Parametri** + **relazione\$1primaria** Specifica la relazione principale. Può essere uno dei seguenti: 1. Relazione tra tabelle 1. Interrogazione con alias Sintassi: `( query ) [ [ AS ] alias ] ` 1. Relazione con alias `Syntax: ( relation ) [ [ AS ] alias ]` **Esempi** ``` CREATE TABLE t1 (c1 INT, c2 INT); INSERT INTO t1 VALUES (0, 1), (1, 2); CREATE TABLE t2 (c1 INT, c2 INT); INSERT INTO t2 VALUES (0, 2), (0, 3); SELECT * FROM t1, LATERAL (SELECT * FROM t2 WHERE t1.c1 = t2.c1); +--------+-------+--------+-------+ | t1.c1 | t1.c2 | t2.c1 | t2.c2 | +-------+--------+--------+-------+ | 0 | 1 | 0 | 3 | | 0 | 1 | 0 | 2 | +-------+--------+--------+-------+ SELECT a, b, c FROM t1, LATERAL (SELECT c1 + c2 AS a), LATERAL (SELECT c1 - c2 AS b), LATERAL (SELECT a * b AS c); +--------+-------+--------+ | a | b | c | +-------+--------+--------+ | 3 | -1 | -3 | | 1 | -1 | -1 | +-------+--------+--------+ ``` #### Clausola LATERAL VIEW **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) La `LATERAL VIEW` clausola viene utilizzata insieme a funzioni generatrici come`EXPLODE`, che genereranno una tabella virtuale contenente una o più righe. `LATERAL VIEW`applicherà le righe a ciascuna riga di output originale. **Sintassi** ``` LATERAL VIEW [ OUTER ] generator_function ( expression [ , ... ] ) [ table_alias ] AS column_alias [ , ... ] ``` **Parametri** + **ESTERNO** Se `OUTER` specificato, restituisce null se un input array/map è vuoto o nullo. + **generator\$1function** Specifica una funzione generatrice (`EXPLODE``INLINE`, e così via). + **table\$1alias** L'alias per, che è facoltativo`generator_function`. + **column\$1alias** Elenca gli alias di colonna di`generator_function`, che possono essere utilizzati nelle righe di output. È possibile avere più alias se sono presenti più `generator_function` colonne di output. **Esempi** ``` CREATE TABLE person (id INT, name STRING, age INT, class INT, address STRING); INSERT INTO person VALUES (100, 'John', 30, 1, 'Street 1'), (200, 'Mary', NULL, 1, 'Street 2'), (300, 'Mike', 80, 3, 'Street 3'), (400, 'Dan', 50, 4, 'Street 4'); SELECT * FROM person LATERAL VIEW EXPLODE(ARRAY(30, 60)) tableName AS c_age LATERAL VIEW EXPLODE(ARRAY(40, 80)) AS d_age; +------+-------+-------+--------+-----------+--------+--------+ | id | name | age | class | address | c_age | d_age | +------+-------+-------+--------+-----------+--------+--------+ | 100 | John | 30 | 1 | Street 1 | 30 | 40 | | 100 | John | 30 | 1 | Street 1 | 30 | 80 | | 100 | John | 30 | 1 | Street 1 | 60 | 40 | | 100 | John | 30 | 1 | Street 1 | 60 | 80 | | 200 | Mary | NULL | 1 | Street 2 | 30 | 40 | | 200 | Mary | NULL | 1 | Street 2 | 30 | 80 | | 200 | Mary | NULL | 1 | Street 2 | 60 | 40 | | 200 | Mary | NULL | 1 | Street 2 | 60 | 80 | | 300 | Mike | 80 | 3 | Street 3 | 30 | 40 | | 300 | Mike | 80 | 3 | Street 3 | 30 | 80 | | 300 | Mike | 80 | 3 | Street 3 | 60 | 40 | | 300 | Mike | 80 | 3 | Street 3 | 60 | 80 | | 400 | Dan | 50 | 4 | Street 4 | 30 | 40 | | 400 | Dan | 50 | 4 | Street 4 | 30 | 80 | | 400 | Dan | 50 | 4 | Street 4 | 60 | 40 | | 400 | Dan | 50 | 4 | Street 4 | 60 | 80 | +------+-------+-------+--------+-----------+--------+--------+ SELECT c_age, COUNT(1) FROM person LATERAL VIEW EXPLODE(ARRAY(30, 60)) AS c_age LATERAL VIEW EXPLODE(ARRAY(40, 80)) AS d_age GROUP BY c_age; +--------+-----------+ | c_age | count(1) | +--------+-----------+ | 60 | 8 | | 30 | 8 | +--------+-----------+ SELECT * FROM person LATERAL VIEW EXPLODE(ARRAY()) tableName AS c_age; +-----+-------+------+--------+----------+--------+ | id | name | age | class | address | c_age | +-----+-------+------+--------+----------+--------+ +-----+-------+------+--------+----------+--------+ SELECT * FROM person LATERAL VIEW OUTER EXPLODE(ARRAY()) tableName AS c_age; +------+-------+-------+--------+-----------+--------+ | id | name | age | class | address | c_age | +------+-------+-------+--------+-----------+--------+ | 100 | John | 30 | 1 | Street 1 | NULL | | 200 | Mary | NULL | 1 | Street 2 | NULL | | 300 | Mike | 80 | 3 | Street 3 | NULL | | 400 | Dan | 50 | 4 | Street 4 | NULL | +------+-------+-------+--------+-----------+--------+ ``` #### Predicato LIKE **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) Un `LIKE` predicato viene utilizzato per cercare uno schema specifico. Questo predicato supporta anche più modelli con i quantificatori che includono`ANY`, e. `SOME` `ALL` **Sintassi** ``` [ NOT ] { LIKE search_pattern [ ESCAPE esc_char ] | [ RLIKE | REGEXP ] regex_pattern } [ NOT ] { LIKE quantifiers ( search_pattern [ , ... ]) } ``` **Parametri** + **modello\$1di ricerca** Specifica uno schema di stringhe in cui eseguire la ricerca mediante la clausola LIKE. Può contenere caratteri speciali per la corrispondenza dei modelli: + `%`corrisponde a zero o più caratteri. + `_`corrisponde esattamente a un carattere. + **esc\$1char** Specifica il carattere di escape. Il carattere di escape predefinito è. `\` + **regex\$1pattern** Specifica un modello di ricerca per espressioni regolari in cui eseguire la ricerca mediante la clausola or. `RLIKE` `REGEXP` + **quantificatori** Speciifica che i quantificatori dei predicati includono, e. `ANY` `SOME` `ALL` `ANY`o `SOME` significa che se uno dei modelli corrisponde all'input, restituisce true. `ALL`significa se tutti i pattern corrispondono all'input, allora restituisce true. **Esempi** ``` CREATE TABLE person (id INT, name STRING, age INT); INSERT INTO person VALUES (100, 'John', 30), (200, 'Mary', NULL), (300, 'Mike', 80), (400, 'Dan', 50), (500, 'Evan_w', 16); SELECT * FROM person WHERE name LIKE 'M%'; +---+----+----+ | id|name| age| +---+----+----+ |300|Mike| 80| |200|Mary|null| +---+----+----+ SELECT * FROM person WHERE name LIKE 'M_ry'; +---+----+----+ | id|name| age| +---+----+----+ |200|Mary|null| +---+----+----+ SELECT * FROM person WHERE name NOT LIKE 'M_ry'; +---+------+---+ | id| name|age| +---+------+---+ |500|Evan_W| 16| |300| Mike| 80| |100| John| 30| |400| Dan| 50| +---+------+---+ SELECT * FROM person WHERE name RLIKE 'M+'; +---+----+----+ | id|name| age| +---+----+----+ |300|Mike| 80| |200|Mary|null| +---+----+----+ SELECT * FROM person WHERE name REGEXP 'M+'; +---+----+----+ | id|name| age| +---+----+----+ |300|Mike| 80| |200|Mary|null| +---+----+----+ SELECT * FROM person WHERE name LIKE '%\_%'; +---+------+---+ | id| name|age| +---+------+---+ |500|Evan_W| 16| +---+------+---+ SELECT * FROM person WHERE name LIKE '%$_%' ESCAPE '$'; +---+------+---+ | id| name|age| +---+------+---+ |500|Evan_W| 16| +---+------+---+ SELECT * FROM person WHERE name LIKE ALL ('%an%', '%an'); +---+----+----+ | id|name| age| +---+----+----+ |400| Dan| 50| +---+----+----+ SELECT * FROM person WHERE name LIKE ANY ('%an%', '%an'); +---+------+---+ | id| name|age| +---+------+---+ |400| Dan| 50| |500|Evan_W| 16| +---+------+---+ SELECT * FROM person WHERE name LIKE SOME ('%an%', '%an'); +---+------+---+ | id| name|age| +---+------+---+ |400| Dan| 50| |500|Evan_W| 16| +---+------+---+ SELECT * FROM person WHERE name NOT LIKE ALL ('%an%', '%an'); +---+----+----+ | id|name| age| +---+----+----+ |100|John| 30| |200|Mary|null| |300|Mike| 80| +---+----+----+ SELECT * FROM person WHERE name NOT LIKE ANY ('%an%', '%an'); +---+------+----+ | id| name| age| +---+------+----+ |100| John| 30| |200| Mary|null| |300| Mike| 80| |500|Evan_W| 16| +---+------+----+ SELECT * FROM person WHERE name NOT LIKE SOME ('%an%', '%an'); +---+------+----+ | id| name| age| +---+------+----+ |100| John| 30| |200| Mary|null| |300| Mike| 80| |500|Evan_W| 16| +---+------+----+ ``` #### OFFSET **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi[Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql). La `OFFSET` clausola viene utilizzata per specificare il numero di righe da saltare prima di iniziare a restituire le righe restituite dall'istruzione. `SELECT` In generale, questa clausola viene utilizzata insieme a per `ORDER BY` garantire che i risultati siano deterministici. **Sintassi** ``` OFFSET integer_expression ``` **Parametri** + **espressione intera** Specifica un'espressione pieghevole che restituisce un numero intero. **Esempi** ``` CREATE TABLE person (name STRING, age INT); INSERT INTO person VALUES ('Jane Doe', 25), ('Pat C', 18), ('Nikki W', 16), ('Juan L', 25), ('John D', 18), ('Jorge S', 16); -- Skip the first two rows. SELECT name, age FROM person ORDER BY name OFFSET 2; +-------+---+ | name|age| +-------+---+ | John D| 18| | Juan L| 25| |Nikki W| 16| |Jane Doe| 25| +-------+---+ -- Skip the first two rows and returns the next three rows. SELECT name, age FROM person ORDER BY name LIMIT 3 OFFSET 2; +-------+---+ | name|age| +-------+---+ | John D| 18| | Juan L| 25| |Nikki W| 16| +-------+---+ -- A function expression as an input to OFFSET. SELECT name, age FROM person ORDER BY name OFFSET length('WAGON'); +-------+---+ | name|age| +-------+---+ |Jane Doe| 25| +-------+---+ ``` #### Clausola PIVOT **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) La `PIVOT` clausola viene utilizzata per la prospettiva dei dati. Possiamo ottenere i valori aggregati in base a valori di colonna specifici, che verranno trasformati in più colonne utilizzate nella `SELECT` clausola. La `PIVOT` clausola può essere specificata dopo il nome della tabella o della sottoquery. **Sintassi** ``` PIVOT ( { aggregate_expression [ AS aggregate_expression_alias ] } [ , ... ] FOR column_list IN ( expression_list ) ) ``` **Parametri** + **aggregate\$1expression** Specifica un'espressione `(SUM(a)` aggregata e così via.). `COUNT(DISTINCT b)` + **aggregate\$1expression\$1alias** Specifica un alias per l'espressione aggregata. + **column\$1list** Contiene colonne nella `FROM` clausola, che specifica le colonne che si desidera sostituire con nuove colonne. È possibile utilizzare parentesi per racchiudere le colonne, ad esempio. `(c1, c2)` + **expression\$1list** Speciifica nuove colonne, che vengono utilizzate per abbinare i valori in `column_list` come condizione di aggregazione. È inoltre possibile aggiungere alias per esse. **Esempi** ``` CREATE TABLE person (id INT, name STRING, age INT, class INT, address STRING); INSERT INTO person VALUES (100, 'John', 30, 1, 'Street 1'), (200, 'Mary', NULL, 1, 'Street 2'), (300, 'Mike', 80, 3, 'Street 3'), (400, 'Dan', 50, 4, 'Street 4'); SELECT * FROM person PIVOT ( SUM(age) AS a, AVG(class) AS c FOR name IN ('John' AS john, 'Mike' AS mike) ); +------+-----------+---------+---------+---------+---------+ | id | address | john_a | john_c | mike_a | mike_c | +------+-----------+---------+---------+---------+---------+ | 200 | Street 2 | NULL | NULL | NULL | NULL | | 100 | Street 1 | 30 | 1.0 | NULL | NULL | | 300 | Street 3 | NULL | NULL | 80 | 3.0 | | 400 | Street 4 | NULL | NULL | NULL | NULL | +------+-----------+---------+---------+---------+---------+ SELECT * FROM person PIVOT ( SUM(age) AS a, AVG(class) AS c FOR (name, age) IN (('John', 30) AS c1, ('Mike', 40) AS c2) ); +------+-----------+-------+-------+-------+-------+ | id | address | c1_a | c1_c | c2_a | c2_c | +------+-----------+-------+-------+-------+-------+ | 200 | Street 2 | NULL | NULL | NULL | NULL | | 100 | Street 1 | 30 | 1.0 | NULL | NULL | | 300 | Street 3 | NULL | NULL | NULL | NULL | | 400 | Street 4 | NULL | NULL | NULL | NULL | +------+-----------+-------+-------+-------+-------+ ``` #### Operatori su set **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) Gli operatori di set vengono utilizzati per combinare due relazioni di input in una sola. OpenSearch SQL supporta tre tipi di operatori di set: + `EXCEPT` o `MINUS` + `INTERSECT` + `UNION` Le relazioni di input devono avere lo stesso numero di colonne e tipi di dati compatibili per le rispettive colonne. **TRANNE** `EXCEPT`e `EXCEPT ALL` restituisce le righe che si trovano in una relazione ma non nell'altra. `EXCEPT`(in alternativa,`EXCEPT DISTINCT`) accetta solo righe distinte senza rimuovere i duplicati dalle righe dei risultati. `EXCEPT ALL` Nota che `MINUS` è un alias per. `EXCEPT` **Sintassi** ``` [ ( ] relation [ ) ] EXCEPT | MINUS [ ALL | DISTINCT ] [ ( ] relation [ ) ] ``` **Esempi** ``` -- Use table1 and table2 tables to demonstrate set operators in this page. SELECT * FROM table1; +---+ | c| +---+ | 3| | 1| | 2| | 2| | 3| | 4| +---+ SELECT * FROM table2; +---+ | c| +---+ | 5| | 1| | 2| | 2| +---+ SELECT c FROM table1 EXCEPT SELECT c FROM table2; +---+ | c| +---+ | 3| | 4| +---+ SELECT c FROM table1 MINUS SELECT c FROM table2; +---+ | c| +---+ | 3| | 4| +---+ SELECT c FROM table1 EXCEPT ALL (SELECT c FROM table2); +---+ | c| +---+ | 3| | 3| | 4| +---+ SELECT c FROM table1 MINUS ALL (SELECT c FROM table2); +---+ | c| +---+ | 3| | 3| | 4| +---+ ``` **INTERSECARE** `INTERSECT`e `INTERSECT ALL` restituisce le righe che si trovano in entrambe le relazioni. `INTERSECT`(in alternativa,`INTERSECT DISTINCT`) accetta solo righe distinte senza rimuovere i duplicati dalle righe dei risultati. `INTERSECT ALL` **Sintassi** ``` [ ( ] relation [ ) ] INTERSECT [ ALL | DISTINCT ] [ ( ] relation [ ) ] ``` **Esempi** ``` (SELECT c FROM table1) INTERSECT (SELECT c FROM table2); +---+ | c| +---+ | 1| | 2| +---+ (SELECT c FROM table1) INTERSECT DISTINCT (SELECT c FROM table2); +---+ | c| +---+ | 1| | 2| +---+ (SELECT c FROM table1) INTERSECT ALL (SELECT c FROM table2); +---+ | c| +---+ | 1| | 2| | 2| +---+ ``` **UNIONE** `UNION`e `UNION ALL` restituisce le righe che si trovano in entrambe le relazioni. `UNION`(in alternativa,`UNION DISTINCT`) accetta solo righe distinte senza rimuovere i duplicati dalle righe dei risultati. `UNION ALL` **Sintassi** ``` [ ( ] relation [ ) ] UNION [ ALL | DISTINCT ] [ ( ] relation [ ) ] ``` **Esempi** ``` (SELECT c FROM table1) UNION (SELECT c FROM table2); +---+ | c| +---+ | 1| | 3| | 5| | 4| | 2| +---+ (SELECT c FROM table1) UNION DISTINCT (SELECT c FROM table2); +---+ | c| +---+ | 1| | 3| | 5| | 4| | 2| +---+ SELECT c FROM table1 UNION ALL (SELECT c FROM table2); +---+ | c| +---+ | 3| | 1| | 2| | 2| | 3| | 4| | 5| | 1| | 2| | 2| +---+ ``` #### Clausola SORT BY **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) La `SORT BY` clausola viene utilizzata per restituire le righe dei risultati ordinate all'interno di ciascuna partizione nell'ordine specificato dall'utente. Quando c'è più di una partizione `SORT BY` può restituire un risultato parzialmente ordinato. Questo è diverso dalla `ORDER BY` clausola che garantisce un ordine totale dell'output. **Sintassi** ``` SORT BY { expression [ sort_direction | nulls_sort_order ] [ , ... ] } ``` **Parametri** + **ORDINA PER** Specifica un elenco di espressioni separate da virgole insieme ai parametri opzionali sort\$1direction e nulls\$1sort\$1order che vengono utilizzati per ordinare le righe all'interno di ciascuna partizione. + **sort\$1direction** Facoltativamente specifica se ordinare le righe in ordine crescente o decrescente. I valori validi per la direzione di ordinamento sono per l'ordine crescente e `ASC` per il decrescente. `DESC` Se la direzione di ordinamento non è specificata in modo esplicito, per impostazione predefinita le righe vengono ordinate in modo crescente. Sintassi: `[ ASC | DESC ]` + **nulls\$1sort\$1order** Specifica facoltativamente se i valori NULL vengono restituiti prima/dopo valori non NULL. Se non `null_sort_order` è specificato, NULLs ordina prima se il criterio di ordinamento è `ASC` e NULLS ordina per ultimo se il criterio di ordinamento è. `DESC` 1. Se `NULLS FIRST` viene specificato, i valori NULL vengono restituiti per primi indipendentemente dal tipo di ordinamento. 2. Se `NULLS LAST` viene specificato, i valori NULL vengono restituiti per ultimi indipendentemente dal tipo di ordinamento. Sintassi: `[ NULLS { FIRST | LAST } ] ` **Esempi** ``` CREATE TABLE person (zip_code INT, name STRING, age INT); INSERT INTO person VALUES (94588, 'Shirley Rodriguez', 50), (94588, 'Juan Li', 18), (94588, 'Anil K', 27), (94588, 'John D', NULL), (94511, 'David K', 42), (94511, 'Aryan B.', 18), (94511, 'Lalit B.', NULL); -- Sort rows by `name` within each partition in ascending manner SELECT name, age, zip_code FROM person SORT BY name; +------------------+----+--------+ | name| age|zip_code| +------------------+----+--------+ | Anil K| 27| 94588| | Juan Li| 18| 94588| | John D|null| 94588| | Shirley Rodriguez| 50| 94588| | Aryan B.| 18| 94511| | David K| 42| 94511| | Lalit B.|null| 94511| +------------------+----+--------+ -- Sort rows within each partition using column position. SELECT name, age, zip_code FROM person SORT BY 1; +----------------+----+----------+ | name| age|zip_code| +------------------+----+--------+ | Anil K| 27| 94588| | Juan Li| 18| 94588| | John D|null| 94588| | Shirley Rodriguez| 50| 94588| | Aryan B.| 18| 94511| | David K| 42| 94511| | Lalit B.|null| 94511| +------------------+----+--------+ -- Sort rows within partition in ascending manner keeping null values to be last. SELECT age, name, zip_code FROM person SORT BY age NULLS LAST; +----+------------------+--------+ | age| name|zip_code| +----+------------------+--------+ | 18| Juan Li| 94588| | 27| Anil K| 94588| | 50| Shirley Rodriguez| 94588| |null| John D| 94588| | 18| Aryan B.| 94511| | 42| David K| 94511| |null| Lalit B.| 94511| +--------------+--------+--------+ -- Sort rows by age within each partition in descending manner, which defaults to NULL LAST. SELECT age, name, zip_code FROM person SORT BY age DESC; +----+------------------+--------+ | age| name|zip_code| +----+------------------+--------+ | 50| Shirley Rodriguez| 94588| | 27| Anil K| 94588| | 18| Juan Li| 94588| |null| John D| 94588| | 42| David K| 94511| | 18| Aryan B.| 94511| |null| Lalit B.| 94511| +----+------------------+--------+ -- Sort rows by age within each partition in descending manner keeping null values to be first. SELECT age, name, zip_code FROM person SORT BY age DESC NULLS FIRST; +----+------------------+--------+ | age| name|zip_code| +----+------------------+--------+ |null| John D| 94588| | 50| Shirley Rodriguez| 94588| | 27| Anil K| 94588| | 18| Juan Li| 94588| |null| Lalit B.| 94511| | 42| David K| 94511| | 18| Aryan B.| 94511| +--------------+--------+--------+ -- Sort rows within each partition based on more than one column with each column having -- different sort direction. SELECT name, age, zip_code FROM person SORT BY name ASC, age DESC; +------------------+----+--------+ | name| age|zip_code| +------------------+----+--------+ | Anil K| 27| 94588| | Juan Li| 18| 94588| | John D|null| 94588| | Shirley Rodriguez| 50| 94588| | Aryan B.| 18| 94511| | David K| 42| 94511| | Lalit B.|null| 94511| +------------------+----+--------+ ``` #### UNPIVOT **Nota** Per vedere quali integrazioni di origini AWS dati supportano questo comando SQL, vedi. [Comandi e funzioni OpenSearch SQL supportati](#supported-directquery-sql) La `UNPIVOT` clausola trasforma più colonne in più righe utilizzate nella clausola. `SELECT` La `UNPIVOT` clausola può essere specificata dopo il nome della tabella o della sottoquery. **Sintassi** ``` UNPIVOT [ { INCLUDE | EXCLUDE } NULLS ] ( { single_value_column_unpivot | multi_value_column_unpivot } ) [[AS] alias] single_value_column_unpivot: values_column FOR name_column IN (unpivot_column [[AS] alias] [, ...]) multi_value_column_unpivot: (values_column [, ...]) FOR name_column IN ((unpivot_column [, ...]) [[AS] alias] [, ...]) ``` **Parametri** + **unpivot\$1column** Contiene le colonne nella `FROM` clausola, che specifica le colonne su cui vogliamo eseguire l'unpivot. + **nome\$1colonna** Il nome della colonna che contiene i nomi delle colonne non ruotate. + **valori\$1colonna** Il nome della colonna che contiene i valori delle colonne non pivotate. **Esempi** ``` CREATE TABLE sales_quarterly (year INT, q1 INT, q2 INT, q3 INT, q4 INT); INSERT INTO sales_quarterly VALUES (2020, null, 1000, 2000, 2500), (2021, 2250, 3200, 4200, 5900), (2022, 4200, 3100, null, null); -- column names are used as unpivot columns SELECT * FROM sales_quarterly UNPIVOT ( sales FOR quarter IN (q1, q2, q3, q4) ); +------+---------+-------+ | year | quarter | sales | +------+---------+-------+ | 2020 | q2 | 1000 | | 2020 | q3 | 2000 | | 2020 | q4 | 2500 | | 2021 | q1 | 2250 | | 2021 | q2 | 3200 | | 2021 | q3 | 4200 | | 2021 | q4 | 5900 | | 2022 | q1 | 4200 | | 2022 | q2 | 3100 | +------+---------+-------+ -- NULL values are excluded by default, they can be included -- unpivot columns can be alias -- unpivot result can be referenced via its alias SELECT up.* FROM sales_quarterly UNPIVOT INCLUDE NULLS ( sales FOR quarter IN (q1 AS Q1, q2 AS Q2, q3 AS Q3, q4 AS Q4) ) AS up; +------+---------+-------+ | year | quarter | sales | +------+---------+-------+ | 2020 | Q1 | NULL | | 2020 | Q2 | 1000 | | 2020 | Q3 | 2000 | | 2020 | Q4 | 2500 | | 2021 | Q1 | 2250 | | 2021 | Q2 | 3200 | | 2021 | Q3 | 4200 | | 2021 | Q4 | 5900 | | 2022 | Q1 | 4200 | | 2022 | Q2 | 3100 | | 2022 | Q3 | NULL | | 2022 | Q4 | NULL | +------+---------+-------+ -- multiple value columns can be unpivoted per row SELECT * FROM sales_quarterly UNPIVOT EXCLUDE NULLS ( (first_quarter, second_quarter) FOR half_of_the_year IN ( (q1, q2) AS H1, (q3, q4) AS H2 ) ); +------+------------------+---------------+----------------+ | id | half_of_the_year | first_quarter | second_quarter | +------+------------------+---------------+----------------+ | 2020 | H1 | NULL | 1000 | | 2020 | H2 | 2000 | 2500 | | 2021 | H1 | 2250 | 3200 | | 2021 | H2 | 4200 | 5900 | | 2022 | H1 | 4200 | 3100 | +------+------------------+---------------+----------------+ ``` # Comandi PPL supportati Le tabelle seguenti mostrano quali comandi PPL sono supportati da OpenSearch Dashboards per interrogare CloudWatch Logs, Amazon S3 o Security Lake e quali comandi supporta Logs Insights. CloudWatch CloudWatch Logs Insights utilizza la stessa sintassi PPL di OpenSearch Dashboards per interrogare CloudWatch Logs e le tabelle si riferiscono a entrambi come Logs. CloudWatch **Nota** Quando si analizzano i dati al di fuori del OpenSearch servizio, i comandi potrebbero essere eseguiti in modo diverso rispetto agli indici. OpenSearch **Topics** + [Comandi](#supported-ppl-commands) + [Funzioni](#supported-ppl-functions) + [Informazioni aggiuntive per gli utenti di CloudWatch Logs Insights che utilizzano PPL OpenSearch](#supported-ppl-for-cloudwatch-users) ## Comandi | Comando PPL | Description | CloudWatch Registri | Simple Storage Service (Amazon S3) | Lago di sicurezza | Esempio di comando | | --- | --- | --- | --- | --- | --- | | [comando fields](#supported-ppl-fields-command) | Visualizza una serie di campi che necessitano di proiezione. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
 fields field1, field2
| | [comando where](#supported-ppl-where-command) | Filtra i dati in base alle condizioni specificate. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
 where field1="success"
| where field2 != "i -023fe0a90929d8822"
| fields field3, col4, col5, col6
| head 1000
| | [comando stats](#supported-ppl-stats-command) | Esegue aggregazioni e calcoli. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
stats count(),
      count(`field1`),
      min(`field1`),
      max(`field1`),
      avg(`field1`)
by field2
| head 1000
| | [comando parse](#supported-ppl-parse-command) | Estrae un pattern di espressione regolare (regex) da una stringa e visualizza il pattern estratto. Il pattern estratto può essere ulteriormente utilizzato per creare nuovi campi o filtrare i dati. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
parse `field1` ".*/(?[^/]+$)"
| where field2 = "requestId"
| fields field2, `field2`
| head 1000
| | [comando patterns](#supported-ppl-patterns-command) | Estrae i modelli di registro da un campo di testo e aggiunge i risultati al risultato della ricerca. Il raggruppamento dei log in base ai relativi schemi semplifica l'aggregazione delle statistiche provenienti da grandi volumi di dati di registro per l'analisi e la risoluzione dei problemi. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/negative_icon.svg)Non supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
patterns new_field='no_numbers' pattern='[0-9]' message
| fields message, no_numbers
| | [comando sort](#supported-ppl-sort-command) | Ordina i risultati visualizzati in base al nome di un campo. Usa **sort - *FieldName***per ordinare in ordine decrescente. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
stats count(),
      count(`field1`),
      min(`field1`) as field1Alias,
      max(`field1`),
      avg(`field1`)
by field2
| sort -field1Alias
| head 1000
| | [comando eval](#supported-ppl-eval-command) | Modifica o elabora il valore di un campo e lo memorizza in un campo diverso. Ciò è utile per modificare matematicamente una colonna, applicare funzioni di stringa a una colonna o applicare funzioni di data a una colonna. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
eval field2 = `field1` * 2
| fields field1, field2
| head 20
| | [comando di ridenominazione](#supported-ppl-rename-command) | Rinomina uno o più campi nei risultati della ricerca. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
rename field2 as field1
| fields field1
| | [comando head](#supported-ppl-head-command) | Limita i risultati dell'interrogazione visualizzati alle prime N righe. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
 fields `@message`
| head 20
| | [comando grok](#supported-ppl-grok-command) | Analizza un campo di testo con un pattern grok basato su un'espressione regolare e aggiunge i risultati al risultato della ricerca. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
 grok email '.+@%{HOSTNAME:host}'
| fields email
| | [comando top](#supported-ppl-top-command) | Trova i valori più frequenti per un campo. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
 top 2 Field1 by Field2
| | [comando dedup](#supported-ppl-dedup-command) | Rimuove le voci duplicate in base ai campi specificati. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
dedup field1
| fields field1, field2, field3
| | [comando join](#supported-ppl-join-commands) | Unisce due set di dati. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
source=customer
| join ON c_custkey = o_custkey orders
| head 10
| | [comando lookup](#supported-ppl-lookup-commands) | Arricchisce i dati di ricerca aggiungendo o sostituendo i dati da un indice di ricerca (tabella delle dimensioni). È possibile estendere i campi di un indice con i valori di una tabella delle dimensioni, aggiungere o sostituire valori quando viene soddisfatta la condizione di ricerca | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/negative_icon.svg)Non supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
where orderType = 'Cancelled'
| lookup account_list, mkt_id AS mkt_code
  replace amount, account_name as name
| stats count(mkt_code), avg(amount)
  by name
| | [comando subquery](#supported-ppl-subquery-commands) | Esegue interrogazioni complesse e annidate all'interno delle istruzioni PPL (Piped Processing Language). | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
where id in [
  subquery source=users
  | where user in [
    subquery source=actions
    | where action="login"
    | fields user
  ]
  | fields uid
]
| | [comando raro](#supported-ppl-rare-command) | Trova i valori meno frequenti di tutti i campi nell'elenco dei campi. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
 rare Field1 by Field2
| | [comando trendline](#supported-ppl-trendline-commands) | Calcola le medie mobili dei campi. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
 trendline sma(2, field1) as field1Alias
| | [comando eventstats](#supported-ppl-eventstats-command) | Arricchisce i dati degli eventi con statistiche riassuntive calcolate. Analizza i campi specifici all'interno degli eventi, calcola varie misure statistiche e quindi aggiunge questi risultati a ciascun evento originale come nuovi campi. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato (eccetto) `count()` | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
 eventstats sum(field1) by field2
| | [comando flatten](#supported-ppl-flatten-command) | Appiattisce un campo. Il campo deve essere di questo tipo: `struct or array>` | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
 source=table | flatten field1
| | [riepilogo del campo](#supported-ppl-field-summary-command) | Calcola le statistiche di base per ogni campo (conteggio, conteggio distinto, min, max, avg, stddev e mean). | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato (un campo per query) | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
where field1 != 200
| fieldsummary includefields=field1 nulls=true
| | [comando fillnull](#supported-ppl-fillnull-command) | Riempie i campi nulli con il valore fornito. Può essere utilizzato in uno o più campi. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
fields field1
| eval field2=field1
| fillnull value=0 field1
| | [comando expand](#supported-ppl-expand-command) | Suddivide un campo contenente più valori in righe separate, creando una nuova riga per ogni valore nel campo specificato. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
expand employee
| stats max(salary) as max
  by state, company
| | [comando describe](#supported-ppl-describe-command) | Ottiene informazioni dettagliate sulla struttura e i metadati di tabelle, schemi e cataloghi | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/negative_icon.svg)Non supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
 describe schema.table
| ## Funzioni | Funzione PPL | Description | CloudWatch Registri | Simple Storage Service (Amazon S3) | Lago di sicurezza | Esempio di comando | | --- | --- | --- | --- | --- | --- | | [Funzioni di stringa PPL](#supported-ppl-string-functions) (`CONCAT`, `CONCAT_WS`, `LENGTH`, `LOWER`, `LTRIM`, `POSITION`, `REVERSE`, `RIGHT`, `RTRIM`, `SUBSTRING`, `TRIM`, `UPPER`) | Funzioni integrate in PPL in grado di manipolare e trasformare stringhe e dati di testo all'interno di query PPL. Ad esempio, convertire maiuscole e minuscole, combinare stringhe, estrarre parti e pulire il testo. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
eval col1Len = LENGTH(col1)
| fields col1Len
| | [Funzioni di data e ora PPL](#supported-ppl-date-time-functions) (`DAY`, `DAYOFMONTH`, `DAY_OF_MONTH`,`DAYOFWEEK`, `DAY_OF_WEEK`, `DAYOFYEAR`, `DAY_OF_YEAR`, `DAYNAME`, `FROM_UNIXTIME`, `HOUR`, `HOUR_OF_DAY`, `LAST_DAY`, `LOCALTIMESTAMP`, `LOCALTIME`, `MAKE_DATE`, `MINUTE`, `MINUTE_OF_HOUR`, `MONTH`, `MONTHNAME`, `MONTH_OF_YEAR`, `NOW`, `QUARTER`, `SECOND`, `SECOND_OF_MINUTE`, `SUBDATE`, `SYSDATE`, `TIMESTAMP`, `UNIX_TIMESTAMP`, `WEEK`, `WEEKDAY`, `WEEK_OF_YEAR`, `DATE_ADD`, `DATE_SUB`, `TIMESTAMPADD`, `TIMESTAMPDIFF`, `UTC_TIMESTAMP`, `CURRENT_TIMEZONE`) | Funzioni integrate per la gestione e la trasformazione dei dati di data e ora nelle query PPL. ******Ad esempio, **date\$1add, date\$1format, datediff e current\$1date**.****** | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
eval newDate = ADDDATE(DATE('2020-08-26'), 1)
| fields newDate
| | [Funzioni di condizione PPL](#supported-ppl-condition-functions) (`EXISTS`, `IF`, `IFNULL`, `ISNOTNULL`, `ISNULL`, `NULLIF`) | Funzioni integrate che eseguono calcoli su più righe per produrre un unico valore riepilogato. **Ad esempio, **sum**, **count**, **avg**, **max** e min.** | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
eval field2 = isnull(col1)
| fields field2, col1, field3
| | [Funzioni matematiche PPL](#supported-ppl-math-functions) (`ABS`, `ACOS`, `ASIN`, `ATAN`, `ATAN2`, `CEIL`, `CEILING`, `CONV`, `COS`, `COT`, `CRC32`, `DEGREES`, `E`, `EXP`, `FLOOR`, `LN`, `LOG`, `LOG2`, `LOG10`, `MOD`, `PI`. `POW`, `POWER`, `RADIANS`, `RAND`, `ROUND`, `SIGN`, `SIN`, `SQRT`, `CBRT`) | Funzioni integrate per eseguire calcoli e trasformazioni matematiche nelle query PPL. Ad esempio: **abs** (valore assoluto), **round** (arrotonda i numeri), **sqrt** (radice quadrata), **pow** (calcolo della potenza) e **ceil** (arrotonda al numero intero più vicino). | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
eval field2 = ACOS(col1)
| fields col1
| | [espressioni PPL](#supported-ppl-expressions) (Operatori aritmetici (`+`,,`*`)`-`, Operatori predicati (,) `>. <` `IN)` | Le funzioni integrate per le espressioni, in particolare le espressioni di valore, restituiscono un valore scalare. Le espressioni hanno tipi e forme diversi. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
where age > (25 + 5)
| fields age
| | [Funzioni degli indirizzi IP PPL](#supported-ppl-ip-address-functions) (`CIDRMATCH`) | Funzioni integrate per la gestione di indirizzi IP come CIDR. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
where cidrmatch(ip, '***********/24')
| fields ip
| | [Funzioni PPL JSON](#supported-ppl-json-functions) (`ARRAY_LENGTH`, `ARRAY_LENGTH`, `JSON`, `JSON_ARRAY`, `JSON_EXTRACT`, `JSON_KEYS`, `JSON_OBJECT`, `JSON_VALID`, `TO_JSON_STRING`) | Funzioni integrate per la gestione di JSON, tra cui array, estrazione e convalida. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
eval `json_extract('{"a":"b"}', '$.a')` = json_extract('{"a":"b"}', '$a')
| | [Funzioni PPL Lambda](#supported-ppl-lambda-functions) (`EXISTS`, `FILTER`, `REDUCE`, `TRANSFORM`) | Funzioni integrate per la gestione di JSON, tra cui array, estrazione e convalida. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/negative_icon.svg)Non supportata | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
eval array = json_array(1, -1, 2),
     result = filter(array, x -> x > 0)
| fields result
| | [funzioni hash crittografiche PPL](#supported-ppl-cryptographic-functions) (`MD5`, `SHA1`, `SHA2`) | Funzioni integrate che consentono di generare impronte digitali uniche di dati, che possono essere utilizzate per la verifica, il confronto o come parte di protocolli di sicurezza più complessi. | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | ![\[alt text not found\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/success_icon.svg)Supportato | 
eval `MD5('hello')` = MD5('hello')
| fields `MD5('hello')`
| ## Informazioni aggiuntive per gli utenti di CloudWatch Logs Insights che utilizzano PPL OpenSearch Sebbene CloudWatch Logs Insights supporti la maggior parte dei comandi e delle funzioni OpenSearch PPL, alcuni comandi e funzioni non sono attualmente supportati. Ad esempio, attualmente non supporta i comandi Lookup in PPL. A partire dal 2 giugno 2025, CloudWatch Logs Insights ora supporta le funzioni JOIN, subqueries, Flatten, Fillnull, Expand, Cidrmatch e JSON in PPL. Per un elenco completo dei comandi e delle funzioni di query supportati, consulta le colonne di Amazon CloudWatch Logs nelle tabelle precedenti. ### Esempi di domande e quote Quanto segue si applica sia agli utenti di CloudWatch Logs Insights che agli utenti che effettuano query sui dati. OpenSearch CloudWatch Per informazioni sui limiti che si applicano all'interrogazione di CloudWatch Logs from OpenSearch Service, consulta [CloudWatch Logs quotas nella Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html) User Guide. I limiti riguardano il numero di gruppi di CloudWatch log su cui è possibile eseguire query, il numero massimo di query simultanee che è possibile eseguire, il tempo massimo di esecuzione delle query e il numero massimo di righe restituite nei risultati. I limiti sono gli stessi indipendentemente dal linguaggio utilizzato per interrogare i log (ovvero OpenSearch PPL, SQL e CloudWatch Logs Insights QL). ### Comandi PPL **Topics** + [comment](#supported-ppl-comment) + [comando di correlazione](#supported-ppl-correlation-commands) + [comando dedup](#supported-ppl-dedup-command) + [comando describe](#supported-ppl-describe-command) + [comando eval](#supported-ppl-eval-command) + [comando eventstats](#supported-ppl-eventstats-command) + [comando expand](#supported-ppl-expand-commands) + [comando explain](#supported-ppl-explain-command) + [comando fillnull](#supported-ppl-fillnull-command) + [comando fields](#supported-ppl-fields-command) + [comando flatten](#supported-ppl-flatten-command) + [comando grok](#supported-ppl-grok-command) + [comando head](#supported-ppl-head-command) + [comando join](#supported-ppl-join-commands) + [comando lookup](#supported-ppl-lookup-commands) + [comando parse](#supported-ppl-parse-command) + [comando patterns](#supported-ppl-patterns-command) + [comando raro](#supported-ppl-rare-command) + [comando di ridenominazione](#supported-ppl-rename-command) + [comando di ricerca](#supported-ppl-search-command) + [comando sort](#supported-ppl-sort-command) + [comando stats](#supported-ppl-stats-command) + [comando subquery](#supported-ppl-subquery-commands) + [comando top](#supported-ppl-top-command) + [comando trendline](#supported-ppl-trendline-commands) + [comando where](#supported-ppl-where-command) + [riepilogo del campo](#supported-ppl-field-summary-command) + [comando expand](#supported-ppl-expand-command) + [Funzioni PPL](#supported-ppl-functions-details) #### comment **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) PPL supporta sia i commenti di riga che i commenti a blocchi. Il sistema non valuta il testo dei commenti. **Commenti di riga** I commenti alle righe iniziano con due barre//e terminano con una nuova riga. Esempio: ``` os> source=accounts | top gender // finds most common gender of all the accounts fetched rows / total rows = 2/2 +----------+ | gender | |----------| | M | | F | +----------+ ``` **Blocca commenti** I commenti di blocco iniziano con una barra seguita da un asterisco\$1 \$1 e terminano con un asterisco seguito da una barra \$1/. Esempio: ``` os> source=accounts | dedup 2 gender /* dedup the document with gender field keep 2 duplication */ | fields account_number, gender fetched rows / total rows = 3/3 +------------------+----------+ | account_number | gender | |------------------+----------| | 1 | M | | 6 | M | | 13 | F | +------------------+----------+ ``` #### comando di correlazione **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) È possibile correlare diverse fonti di dati in base a dimensioni e intervalli di tempo comuni. Questa correlazione è fondamentale quando si ha a che fare con grandi quantità di dati provenienti da vari settori verticali che condividono gli stessi periodi di tempo ma non sono formalmente sincronizzati. Correlando queste diverse fonti di dati in base a intervalli di tempo e dimensioni simili, puoi arricchire i dati e scoprire informazioni preziose. **Esempio** Il dominio dell'osservabilità ha tre fonti di dati distinte: + Log + Metriche + Tracce Queste fonti di dati potrebbero condividere dimensioni comuni. Per passare da una fonte di dati all'altra, è necessario correlarle correttamente. Utilizzando le convenzioni di denominazione semantica, puoi identificare gli elementi condivisi tra log, tracce e metriche. Esempio: ``` { "@timestamp": "2018-07-02T22:23:00.186Z", "aws": { "elb": { "backend": { "http": { "response": { "status_code": 500 } }, "ip": "********", "port": "80" }, ... "target_port": [ "10.0.0.1:80" ], "target_status_code": [ "500" ], "traceId": "Root=1-58337262-36d228ad5d99923122bbe354", "type": "http" } }, "cloud": { "provider": "aws" }, "http": { "request": { ... }, "communication": { "source": { "address": "**************", "ip": "**************", "port": 2817 } }, "traceId": "Root=1-58337262-36d228ad5d99923122bbe354" } ``` Questo esempio mostra un log AWS ELB proveniente da un servizio che risiede su. AWS Mostra una risposta HTTP di backend con un codice di stato 500, che indica un errore. Ciò potrebbe attivare un avviso o far parte del normale processo di monitoraggio. Il passo successivo è raccogliere dati pertinenti su questo evento per un'indagine approfondita. Anche se potreste essere tentati di interrogare tutti i dati relativi al periodo di tempo, questo approccio può rivelarsi faticoso. Potresti finire con troppe informazioni e dedicare più tempo a filtrare i dati irrilevanti che a identificare la causa principale. Puoi invece utilizzare un approccio più mirato correlando i dati provenienti da fonti diverse. Puoi utilizzare queste dimensioni per la correlazione: + **IP -** `"ip": "10.0.0.1" | "ip": "**************"` + **Porta** - `"port": 2817 | "target_port": "10.0.0.1:80"` Supponendo che tu abbia accesso a tracce e indici metrici aggiuntivi e che tu abbia familiarità con la struttura dello schema, puoi creare una query di correlazione più precisa. Ecco un esempio di documento con indice di traccia contenente informazioni HTTP che potresti voler correlare: ``` { "traceId": "c1d985bd02e1dbb85b444011f19a1ecc", "spanId": "55a698828fe06a42", "traceState": [], "parentSpanId": "", "name": "mysql", "kind": "CLIENT", "@timestamp": "2021-11-13T20:20:39+00:00", "events": [ { "@timestamp": "2021-03-25T17:21:03+00:00", ... } ], "links": [ { "traceId": "c1d985bd02e1dbb85b444011f19a1ecc", "spanId": "55a698828fe06a42w2", }, "droppedAttributesCount": 0 } ], "resource": { "service@name": "database", "telemetry@sdk@name": "opentelemetry", "host@hostname": "ip-172-31-10-8.us-west-2.compute.internal" }, "status": { ... }, "attributes": { "http": { "user_agent": { "original": "Mozilla/5.0" }, "network": { ... } }, "request": { ... } }, "response": { "status_code": "200", "body": { "size": 500 } }, "client": { "server": { "socket": { "address": "***********", "domain": "example.com", "port": 80 }, "address": "***********", "port": 80 }, "resend_count": 0, "url": { "full": "http://example.com" } }, "server": { "route": "/index", "address": "***********", "port": 8080, "socket": { ... }, "client": { ... } }, "url": { ... } } } } } ``` In questo approccio puoi vedere gli `traceId` e gli http client/server `ip` che possono essere correlati ai log elb per comprendere meglio il comportamento e le condizioni del sistema. **Nuovo comando di interrogazione di correlazione** Ecco il nuovo comando che consentirebbe questo tipo di indagine: ``` source alb_logs, traces | where alb_logs.ip="10.0.0.1" AND alb_logs.cloud.provider="aws"| correlate exact fields(traceId, ip) scope(@timestamp, 1D) mapping(alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId ) ``` Ecco cosa fa ogni parte del comando: 1. `source alb_logs, traces`- Seleziona le fonti di dati che desideri correlare. 1. `where ip="10.0.0.1" AND cloud.provider="aws"`- Questo restringe l'ambito della ricerca. 1. `correlate exact fields(traceId, ip)`- Ciò indica al sistema di correlare i dati in base alle corrispondenze esatte dei seguenti campi: + Il `ip` campo ha una condizione di filtro esplicita, quindi verrà utilizzato nella correlazione per tutte le fonti di dati. + Il `traceId` campo non ha un filtro esplicito, quindi corrisponderà agli stessi traceID in tutte le fonti di dati. I nomi dei campi indicano il significato logico della funzione all'interno del comando di correlazione. La condizione di unione effettiva si basa sull'istruzione di mappatura fornita. Il termine `exact` indica che le istruzioni di correlazione richiederanno che tutti i campi corrispondano per soddisfare l'istruzione di query. Il termine `approximate` cercherà di corrispondere nel migliore dei casi e non rifiuterà le righe con corrispondenze parziali. **Risolvere diversi tipi di mappatura dei campi** Nei casi in cui lo stesso campo logico (ad esempio`ip`) ha nomi diversi tra le fonti di dati, è necessario fornire la mappatura esplicita dei campi del percorso. Per risolvere questo problema, puoi estendere le condizioni di correlazione in modo che corrispondano nomi di campo diversi con significati logici simili. Ecco come puoi farlo: ``` alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId ``` Per ogni campo che partecipa al join di correlazione, è necessario fornire una dichiarazione di mappatura pertinente che includa tutte le tabelle che devono essere unite da questo comando di correlazione. **Esempio** In questo esempio, ci sono 2 fonti: `alb_logs, traces` Ci sono 2 campi: `traceId, ip` Esistono 2 istruzioni di mappatura: `alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId` **Definizione dei tempi di correlazione** Per semplificare il lavoro svolto dal motore di esecuzione (driver), puoi aggiungere l'istruzione scope. Ciò indica in modo esplicito alla join query l'ora in cui deve spaziare per questa ricerca. `scope(@timestamp, 1D)`i In questo esempio, l'ambito di ricerca si concentra su base giornaliera, quindi le correlazioni che appaiono nello stesso giorno vengono raggruppate. Questo meccanismo di definizione dell'ambito semplifica e consente un migliore controllo sui risultati, abilitando una risoluzione incrementale della ricerca in base alle esigenze dell'utente. **Driver di supporto** Il nuovo comando di correlazione è in realtà un comando join «nascosto». Pertanto, solo i seguenti driver PPL supportano questo comando. In questi driver, il comando di correlazione verrà tradotto direttamente nel piano logico Catalyst Join appropriato. **Esempio** `source alb_logs, traces, metrics | where ip="10.0.0.1" AND cloud.provider="aws"| correlate exact on (ip, port) scope(@timestamp, 2018-07-02T22:23:00, 1 D)` **Piano logico:** ``` 'Project [*] +- 'Join Inner, ('ip && 'port) :- 'Filter (('ip === "10.0.0.1" & 'cloud.provider === "aws") & inTimeScope('@timestamp, "2018-07-02T22:23:00", "1 D")) +- 'UnresolvedRelation [alb_logs] +- 'Join Inner, ('ip & 'port) :- 'Filter (('ip === "10.0.0.1" & 'cloud.provider === "aws") & inTimeScope('@timestamp, "2018-07-02T22:23:00", "1 D")) +- 'UnresolvedRelation [traces] +- 'Filter (('ip === "10.0.0.1" & 'cloud.provider === "aws") & inTimeScope('@timestamp, "2018-07-02T22:23:00", "1 D")) +- 'UnresolvedRelation [metrics] ``` Il motore catalyst ottimizza questa query in base all'ordinamento di giunzione più efficiente. #### comando dedup **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Utilizzate il `dedup` comando per rimuovere documenti identici dai risultati della ricerca in base ai campi specificati. **Sintassi** Utilizzare la seguente sintassi: ``` dedup [int] [keepempty=] [consecutive=] ``` **`int`** + Opzionale. + Il `dedup` comando conserva più eventi per ogni combinazione quando viene specificata. Il numero per deve essere maggiore di 0. Se non si specifica un numero, viene mantenuto solo il primo evento che si verifica. Tutti gli altri duplicati vengono rimossi dai risultati. + Impostazione predefinita: 1 **`keepempty`** + Opzionale. + Se vero, mantiene i documenti in cui qualsiasi campo dell'elenco dei campi ha un valore NULL o è MANCANTE. + Impostazione predefinita: false **`consecutive`** + Opzionale. + Se vero, rimuove solo gli eventi con combinazioni di valori duplicate consecutive. + Impostazione predefinita: false **`field-list`** + Obbligatorio. + Un elenco di campi delimitato da virgole. È richiesto almeno un campo. **Esempio 1: deduplicazione per un campo** Questo esempio mostra come deduplicare i documenti utilizzando il campo gender. Interrogazione PPL: ``` os> source=accounts | dedup gender | fields account_number, gender; fetched rows / total rows = 2/2 +------------------+----------+ | account_number | gender | |------------------+----------| | 1 | M | | 13 | F | +------------------+----------+ ``` **Esempio 2: Conserva 2 documenti duplicati** L'esempio mostra come deduplicare i documenti con il campo relativo al genere, conservando due duplicati. Interrogazione PPL: ``` os> source=accounts | dedup 2 gender | fields account_number, gender; fetched rows / total rows = 3/3 +------------------+----------+ | account_number | gender | |------------------+----------| | 1 | M | | 6 | M | | 13 | F | +------------------+----------+ ``` **Esempio 3: Mantieni o ignora il campo vuoto per impostazione predefinita** L'esempio mostra come deduplicare il documento mantenendo il campo con valore nullo. Interrogazione PPL: ``` os> source=accounts | dedup email keepempty=true | fields account_number, email; fetched rows / total rows = 4/4 +------------------+-----------------------+ | account_number | email | +------------------+-----------------------+ | 1 | john_doe@example.com | | 6 | jane_doe@example.com | | 13 | null | | 18 | juan_li@example.com | +------------------+-----------------------+ ``` L'esempio mostra come deduplicare il documento ignorando il campo del valore vuoto. Interrogazione PPL: ``` os> source=accounts | dedup email | fields account_number, email; fetched rows / total rows = 3/3 +------------------+-----------------------+ | account_number | email | +------------------+-----------------------+ | 1 | john_doe@example.com | | 6 | jane_doe@example.com | | 18 | juan_li@example.com | +------------------+-----------------------+ ``` **Esempio 4: deduplicazione in documenti consecutivi** L'esempio mostra come eseguire la deduplicazione in documenti consecutivi. Interrogazione PPL: ``` os> source=accounts | dedup gender consecutive=true | fields account_number, gender; fetched rows / total rows = 3/3 +------------------+----------+ | account_number | gender | +------------------+----------+ | 1 | M | | 13 | F | | 18 | M | +------------------+----------+ ``` **Esempi aggiuntivi** + `source = table | dedup a | fields a,b,c` + `source = table | dedup a,b | fields a,b,c` + `source = table | dedup a keepempty=true | fields a,b,c` + `source = table | dedup a,b keepempty=true | fields a,b,c` + `source = table | dedup 1 a | fields a,b,c` + `source = table | dedup 1 a,b | fields a,b,c` + `source = table | dedup 1 a keepempty=true | fields a,b,c` + `source = table | dedup 1 a,b keepempty=true | fields a,b,c` + `source = table | dedup 2 a | fields a,b,c` + `source = table | dedup 2 a,b | fields a,b,c` + `source = table | dedup 2 a keepempty=true | fields a,b,c` + `source = table | dedup 2 a,b keepempty=true | fields a,b,c` + `source = table | dedup 1 a consecutive=true| fields a,b,c`(la deduplicazione consecutiva non è supportata) **Limitazione** + Per `| dedup 2 a, b keepempty=false` ``` DataFrameDropColumns('_row_number_) +- Filter ('_row_number_ <= 2) // allowed duplication = 2 +- Window [row_number() windowspecdefinition('a, 'b, 'a ASC NULLS FIRST, 'b ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS _row_number_], ['a, 'b], ['a ASC NULLS FIRST, 'b ASC NULLS FIRST] +- Filter (isnotnull('a) AND isnotnull('b)) // keepempty=false +- Project +- UnresolvedRelation ``` + Per `| dedup 2 a, b keepempty=true` ``` Union :- DataFrameDropColumns('_row_number_) : +- Filter ('_row_number_ <= 2) : +- Window [row_number() windowspecdefinition('a, 'b, 'a ASC NULLS FIRST, 'b ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS _row_number_], ['a, 'b], ['a ASC NULLS FIRST, 'b ASC NULLS FIRST] : +- Filter (isnotnull('a) AND isnotnull('b)) : +- Project : +- UnresolvedRelation +- Filter (isnull('a) OR isnull('b)) +- Project +- UnresolvedRelation ``` #### comando describe **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Utilizzate il `describe` comando per ottenere informazioni dettagliate sulla struttura e i metadati di tabelle, schemi e cataloghi. Di seguito sono riportati vari esempi e casi d'uso del comando. `describe` **Describe** + `describe table`Questo comando è uguale al comando `DESCRIBE EXTENDED table` SQL + `describe schema.table` + `describe schema.`table`` + `describe catalog.schema.table` + `describe catalog.schema.`table`` + `describe `catalog`.`schema`.`table`` #### comando eval **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Il `eval` comando valuta l'espressione e aggiunge il risultato al risultato della ricerca. **Sintassi** Utilizzare la seguente sintassi: ``` eval = ["," = ]... ``` + `field`: Obbligatorio. Se il nome del campo non esiste, viene aggiunto un nuovo campo. Se il nome del campo esiste già, verrà sovrascritto. + `expression`: Obbligatorio. Qualsiasi espressione supportata dal sistema. **Esempio 1: creare il nuovo campo** Questo esempio mostra come creare un nuovo `doubleAge` campo per ogni documento. Il nuovo `doubleAge` è il risultato della valutazione dell'età moltiplicato per 2. Interrogazione PPL: ``` os> source=accounts | eval doubleAge = age * 2 | fields age, doubleAge ; fetched rows / total rows = 4/4 +-------+-------------+ | age | doubleAge | |-------+-------------| | 32 | 64 | | 36 | 72 | | 28 | 56 | | 33 | 66 | +-------+-------------+ ``` **Esempio 2: sovrascrivi il campo esistente** Questo esempio mostra come sovrascrivere il campo età esistente con age plus 1. Interrogazione PPL: ``` os> source=accounts | eval age = age + 1 | fields age ; fetched rows / total rows = 4/4 +-------+ | age | |-------| | 33 | | 37 | | 29 | | 34 | +-------+ ``` **Esempio 3: crea il nuovo campo con il campo definito in eval** Questo esempio mostra come creare un nuovo `ddAge` campo con un campo definito nel comando eval. Il nuovo campo `ddAge` è il risultato della valutazione di `doubleAge` moltiplicato per 2, dove `doubleAge` è definito nel comando eval. Interrogazione PPL: ``` os> source=accounts | eval doubleAge = age * 2, ddAge = doubleAge * 2 | fields age, doubleAge, ddAge ; fetched rows / total rows = 4/4 +-------+-------------+---------+ | age | doubleAge | ddAge | |-------+-------------+---------| | 32 | 64 | 128 | | 36 | 72 | 144 | | 28 | 56 | 112 | | 33 | 66 | 132 | +-------+-------------+---------+ ``` Ipotesi:`a`,`b`, `c` sono campi esistenti in `table` **Esempi aggiuntivi** + `source = table | eval f = 1 | fields a,b,c,f` + `source = table | eval f = 1`(campi di output a, b, c, f) + `source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t` + `source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5` + `source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h` + `source = table | eval f = a * 2, h = f * 2 | fields a,f,h` + `source = table | eval f = a * 2, h = b | stats avg(f) by h` + `source = table | eval f = ispresent(a)` + `source = table | eval r = coalesce(a, b, c) | fields r` + `source = table | eval e = isempty(a) | fields e` + `source = table | eval e = isblank(a) | fields e` + `source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')` + `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')` + `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))` + `source = table | eval f = a in ('foo', 'bar') | fields f` + `source = table | eval f = a not in ('foo', 'bar') | fields f` **Valuta con un esempio di caso:** ``` source = table | eval e = eval status_category = case(a >= 200 AND a < 300, 'Success', a >= 300 AND a < 400, 'Redirection', a >= 400 AND a < 500, 'Client Error', a >= 500, 'Server Error' else 'Unknown') ``` **Valuta con un altro esempio di caso:** Ipotesi:`a`,`b`, `c` sono campi esistenti in `table` **Esempi aggiuntivi** + `source = table | eval f = 1 | fields a,b,c,f` + `source = table | eval f = 1`(campi di output a, b, c, f) + `source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t` + `source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5` + `source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h` + `source = table | eval f = a * 2, h = f * 2 | fields a,f,h` + `source = table | eval f = a * 2, h = b | stats avg(f) by h` + `source = table | eval f = ispresent(a)` + `source = table | eval r = coalesce(a, b, c) | fields r` + `source = table | eval e = isempty(a) | fields e` + `source = table | eval e = isblank(a) | fields e` + `source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')` + `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')` + `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))` + `source = table | eval f = a in ('foo', 'bar') | fields f` + `source = table | eval f = a not in ('foo', 'bar') | fields f` **Valuta con un esempio di caso:** ``` source = table | eval e = eval status_category = case(a >= 200 AND a < 300, 'Success', a >= 300 AND a < 400, 'Redirection', a >= 400 AND a < 500, 'Client Error', a >= 500, 'Server Error' else 'Unknown') ``` **Valuta con un altro esempio di caso:** ``` source = table | where ispresent(a) | eval status_category = case(a >= 200 AND a < 300, 'Success', a >= 300 AND a < 400, 'Redirection', a >= 400 AND a < 500, 'Client Error', a >= 500, 'Server Error' else 'Incorrect HTTP status code' ) | stats count() by status_category ``` **Limitazioni** + La sovrascrittura dei campi esistenti non è supportata. Le query che tentano di farlo genereranno delle eccezioni con il messaggio «Il riferimento 'a' è ambiguo». ``` - `source = table | eval a = 10 | fields a,b,c` - `source = table | eval a = a * 2 | stats avg(a)` - `source = table | eval a = abs(a) | where a > 0` - `source = table | eval a = signum(a) | where a < 0` ``` #### comando eventstats **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Utilizzate il `eventstats` comando per arricchire i dati degli eventi con statistiche di riepilogo calcolate. Funziona analizzando campi specifici all'interno degli eventi, calcolando varie misure statistiche e quindi aggiungendo questi risultati come nuovi campi a ciascun evento originale. **Aspetti chiave di eventstats** 1. Esegue calcoli sull'intero set di risultati o all'interno di gruppi definiti. 1. Gli eventi originali rimangono intatti, con nuovi campi aggiunti per contenere i risultati statistici. 1. Il comando è particolarmente utile per l'analisi comparativa, l'identificazione di valori anomali o l'aggiunta di un contesto aggiuntivo ai singoli eventi. **Differenza tra stats e eventstats** `eventstats`I comandi `stats` and vengono entrambi utilizzati per il calcolo delle statistiche, ma presentano alcune differenze fondamentali nel modo in cui funzionano e nei risultati che producono. **Formato di output** + `stats`: produce una tabella di riepilogo con solo le statistiche calcolate. + `eventstats`: aggiunge le statistiche calcolate come nuovi campi agli eventi esistenti, preservando i dati originali. **Conservazione degli eventi** + `stats`: Riduce il set di risultati al solo riepilogo statistico, eliminando i singoli eventi. + `eventstats`: conserva tutti gli eventi originali e aggiunge nuovi campi con le statistiche calcolate. **Casi d’uso** + `stats`: Ideale per creare report o dashboard di riepilogo. Spesso utilizzato come comando finale per riepilogare i risultati. + `eventstats`: Utile quando è necessario arricchire gli eventi con un contesto statistico per ulteriori analisi o filtri. Può essere utilizzato durante la ricerca per aggiungere statistiche da utilizzare nei comandi successivi. **Sintassi** Utilizzare la seguente sintassi: ``` eventstats ... [by-clause] ``` **Aggregazione** + Obbligatorio. + Una funzione di aggregazione. + L'argomento dell'aggregazione deve essere un campo. **clausola secondaria** + Opzionale. + Sintassi: `by [span-expression,] [field,]...` + La clausola by può includere campi ed espressioni come funzioni scalari e funzioni di aggregazione. È inoltre possibile utilizzare la clausola span per suddividere un campo specifico in bucket di intervalli uguali. Il comando eventstats esegue quindi l'aggregazione in base a questi span bucket. + Impostazione predefinita: se non si specifica una clausola by, il comando eventstats si aggrega sull'intero set di risultati. **espressione span-expression** + Facoltativo, al massimo uno. + Sintassi: `span(field_expr, interval_expr)` + L'unità dell'espressione dell'intervallo è l'unità naturale di default. Tuttavia, per i campi relativi ai tipi di data e ora, è necessario specificare l'unità nell'espressione dell'intervallo quando si utilizzano unità di data/ora. Ad esempio, per dividere il campo `age` in bucket per 10 anni, usa. `span(age, 10)` Per i campi basati sul tempo, puoi dividere un `timestamp` campo in intervalli orari utilizzando. `span(timestamp, 1h)` **Unità di tempo disponibili** | Unità di intervallo di ampiezza | | --- | | millisecondo (ms) | | secondo/i | | minuto (m, distinzione tra maiuscole e minuscole) | | ora (h) | | giorno (d) | | settimana (e) | | mese (M, distinzione tra maiuscole e minuscole) | | trimestre (q) | | anno (y) | **Funzioni di aggregazione** **`COUNT`** `COUNT`restituisce un conteggio del numero di espr nelle righe recuperate da un'istruzione SELECT. Per CloudWatch Logs utilizza le query, `COUNT` non è supportata. Esempio: ``` os> source=accounts | eventstats count(); fetched rows / total rows = 4/4 +----------------+----------+-----------+----------+-----+--------+--------------------+------------+--------------------------+--------+-------+---------+ | account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | count() | +----------------+----------+-----------+----------+-----+--------+--------------------+------------+--------------------------+--------+-------+---------+ | 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 4 | | 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | AnyCompany | marymajor@anycompany.com | Dante | TN | 4 | | 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 4 | | 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 4 | +----------------+----------+-----------+----------+-----+--------+--------------------+------------+--------------------------+--------+-------+---------+ ``` **`SUM`** `SUM(expr)`restituisce la somma di expr. Esempio: ``` os> source=accounts | eventstats sum(age) by gender; fetched rows / total rows = 4/4 +----------------+----------+-----------+----------+-----+--------+-----------------------+------------+--------------------------+--------+-------+--------------------+ | account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | sum(age) by gender | +----------------+----------+-----------+----------+-----+--------+-----------------------+------------+--------------------------+--------+-------+--------------------+ | 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 101 | | 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | AnyCompany | marymajor@anycompany.com | Dante | TN | 101 | | 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 28 | | 18 | 4180 | Juan | Li | 33 | M | 467 Example Court | | juanli@exampleorg.com | Orick | MD | 101 | +----------------+----------+-----------+----------+-----+--------+-----------------------+------------+--------------------------+--------+-------+--------------------+ ``` **`AVG`** `AVG(expr)`restituisce il valore medio di expr. Esempio: ``` os> source=accounts | eventstats avg(age) by gender; fetched rows / total rows = 4/4 +----------------+----------+-----------+----------+-----+--------+-----------------------+------------+---------------------------+--------+-------+--------------------+ | account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | avg(age) by gender | +----------------+----------+-----------+----------+-----+--------+-----------------------+------------+---------------------------+--------+-------+--------------------+ | 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 33.67 | | 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 33.67 | | 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 28.00 | | 18 | 4180 | Juan | Li | 33 | M | 467 Example Court | | juanli@exampleorg.com | Orick | MD | 33.67 | +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------+ ``` **MAX** `MAX(expr)`Restituisce il valore massimo di expr. Esempio ``` os> source=accounts | eventstats max(age); fetched rows / total rows = 4/4 +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+ | account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | max(age) | +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+ | 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 36 | | 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 36 | | 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 36 | | 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 36 | +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+ ``` **MIN** `MIN(expr)`Restituisce il valore minimo di expr. Esempio ``` os> source=accounts | eventstats min(age); fetched rows / total rows = 4/4 +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+ | account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | min(age) | +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+ | 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 28 | | 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 28 | | 13 | 32838 | Nikki | Wolf | 28 | F | *** Any Street | AnyOrg | | Nogal | VA | 28 | | 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 28 | +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+ ``` **STDDEV\$1SAMP** `STDDEV_SAMP(expr)`Restituisce la deviazione standard del campione di expr. Esempio ``` os> source=accounts | eventstats stddev_samp(age); fetched rows / total rows = 4/4 +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+ | account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | stddev_samp(age) | +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+ | 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 3.304037933599835 | | 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 3.304037933599835 | | 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 3.304037933599835 | | 18 | 4180 | Juan | Li | 33 | M | 467 Example Court | | juanli@exampleorg.com | Orick | MD | 3.304037933599835 | +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+ ``` **STDDEV\$1POP** `STDDEV_POP(expr)`Restituisce la deviazione standard della popolazione di expr. Esempio ``` os> source=accounts | eventstats stddev_pop(age); fetched rows / total rows = 4/4 +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+ | account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | stddev_pop(age) | +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+ | 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 2.**************** | | 6 | 5686 | Mary | Major | 36 | M | *** Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 2.**************** | | 13 | 32838 | Nikki | Wolf | 28 | F | *** Any Street | AnyOrg | | Nogal | VA | 2.**************** | | 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 2.**************** | +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+ ``` **PERCENTILE o PERCENTILE\$1APPROX** `PERCENTILE(expr, percent)`o `PERCENTILE_APPROX(expr, percent)` Restituisce il valore percentile approssimativo di expr alla percentuale specificata. **percentuale** + Il numero deve essere una costante compresa tra 0 e 100. Esempio ``` os> source=accounts | eventstats percentile(age, 90) by gender; fetched rows / total rows = 4/4 +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------------------+ | account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | percentile(age, 90) by gender | +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------------------+ | 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 36 | | 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 36 | | 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 28 | | 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 36 | +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------------------+ ``` **Esempio 1: calcola la media, la somma e il conteggio di un campo per gruppo** L'esempio mostra come calcolare l'età media, la somma dell'età e il conteggio degli eventi di tutti gli account raggruppati per genere. ``` os> source=accounts | eventstats avg(age) as avg_age, sum(age) as sum_age, count() as count by gender; fetched rows / total rows = 4/4 +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+ | account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | avg_age | sum_age | count | +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+ | 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 33.666667 | 101 | 3 | | 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 33.666667 | 101 | 3 | | 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 28.000000 | 28 | 1 | | 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 33.666667 | 101 | 3 | +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+ ``` **Esempio 2: calcola il conteggio per un intervallo** L'esempio ottiene il conteggio dell'età per un intervallo di 10 anni. ``` os> source=accounts | eventstats count(age) by span(age, 10) as age_span fetched rows / total rows = 4/4 +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+ | account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | age_span | +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+ | 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 3 | | 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 3 | | 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 1 | | 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 3 | +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+ ``` **Esempio 3: calcola il conteggio in base al sesso e all'intervallo** L'esempio ottiene il conteggio dell'età per intervallo di 5 anni e il gruppo per sesso. ``` os> source=accounts | eventstats count() as cnt by span(age, 5) as age_span, gender fetched rows / total rows = 4/4 +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+ | account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | cnt | +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+ | 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 2 | | 6 | 5686 | Mary | Majo | 36 | M | 671 Example Street | Any Company | hattiebond@anycompany.com | Dante | TN | 1 | | 13 | 32838 | Nikki | Wolf | 28 | F | *** Any Street | AnyOrg | | Nogal | VA | 1 | | 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 2 | +----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+ ``` **Utilizzo** + `source = table | eventstats avg(a)` + `source = table | where a < 50 | eventstats avg(c)` + `source = table | eventstats max(c) by b` + `source = table | eventstats count(c) by b | head 5` + `source = table | eventstats distinct_count(c)` + `source = table | eventstats stddev_samp(c)` + `source = table | eventstats stddev_pop(c)` + `source = table | eventstats percentile(c, 90)` + `source = table | eventstats percentile_approx(c, 99)` **Aggregazioni con span** + `source = table | eventstats count(a) by span(a, 10) as a_span` + `source = table | eventstats sum(age) by span(age, 5) as age_span | head 2` + `source = table | eventstats avg(age) by span(age, 20) as age_span, country | sort - age_span | head 2` **Aggregazioni con intervallo di tempo (funzione tumble windowing)** + `source = table | eventstats sum(productsAmount) by span(transactionDate, 1d) as age_date | sort age_date` + `source = table | eventstats sum(productsAmount) by span(transactionDate, 1w) as age_date, productId` **Le aggregazioni sono raggruppate per più livelli** + `source = table | eventstats avg(age) as avg_state_age by country, state | eventstats avg(avg_state_age) as avg_country_age by country` + `source = table | eventstats avg(age) as avg_city_age by country, state, city | eval new_avg_city_age = avg_city_age - 1 | eventstats avg(new_avg_city_age) as avg_state_age by country, state | where avg_state_age > 18 | eventstats avg(avg_state_age) as avg_adult_country_age by country` #### comando expand **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Utilizzate il `expand` comando per appiattire un campo di tipo: + `Array` + `Map` **Sintassi** Utilizzare la seguente sintassi: ``` expand [As alias] ``` **field** + Il campo da espandere (esplodere). Deve essere di un tipo supportato. **alias** + Opzionale. Il nome da utilizzare al posto del nome del campo originale. **Utilizzo** Il `expand` comando produce una riga per ogni elemento nell'array o nel campo della mappa specificato, dove: + Gli elementi dell'array diventano righe singole. + Le coppie chiave-valore della mappa sono suddivise in righe separate, con ogni valore chiave rappresentato come una riga. + Quando viene fornito un alias, i valori esplosi vengono rappresentati sotto l'alias anziché nel nome del campo originale. + Questo può essere usato in combinazione con altri comandi, come `stats``eval`, e `parse` per manipolare o estrarre i dati dopo l'espansione. **Esempi** + `source = table | expand employee | stats max(salary) as max by state, company` + `source = table | expand employee as worker | stats max(salary) as max by state, company` + `source = table | expand employee as worker | eval bonus = salary * 3 | fields worker, bonus` + `source = table | expand employee | parse description '(?.+@.+)' | fields employee, email` + `source = table | eval array=json_array(1, 2, 3) | expand array as uid | fields name, occupation, uid` + `source = table | expand multi_valueA as multiA | expand multi_valueB as multiB` #### comando explain **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Il `explain` comando consente di comprendere i piani di esecuzione delle query, consentendovi di analizzare e ottimizzare le query per migliorare le prestazioni. Questa introduzione fornisce una panoramica concisa dello scopo del comando explain e della sua importanza nell'ottimizzazione delle query. **Comment** + `source=accounts | top gender // finds most common gender of all the accounts`(commento di riga) + `source=accounts | dedup 2 gender /* dedup the document with gender field keep 2 duplication */ | fields account_number, gender`(commento del blocco) **Describe** + `describe table`Questo comando è uguale al comando `DESCRIBE EXTENDED table` SQL + `describe schema.table` + `describe schema.`table`` + `describe catalog.schema.table` + `describe catalog.schema.`table`` + `describe `catalog`.`schema`.`table`` **Spiegazione** + `explain simple | source = table | where a = 1 | fields a,b,c` + `explain extended | source = table` + `explain codegen | source = table | dedup a | fields a,b,c` + `explain cost | source = table | sort a | fields a,b,c` + `explain formatted | source = table | fields - a` + `explain simple | describe table` **Campi** + `source = table` + `source = table | fields a,b,c` + `source = table | fields + a,b,c` + `source = table | fields - b,c` + `source = table | eval b1 = b | fields - b1,c` **Riepilogo del campo** + `source = t | fieldsummary includefields=status_code nulls=false` + `source = t | fieldsummary includefields= id, status_code, request_path nulls=true` + `source = t | where status_code != 200 | fieldsummary includefields= status_code nulls=true` **Campo annidato** + `source = catalog.schema.table1, catalog.schema.table2 | fields A.nested1, B.nested1` + `source = catalog.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield` + `source = catalog.schema.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield` **Filtri** + `source = table | where a = 1 | fields a,b,c` + `source = table | where a >= 1 | fields a,b,c` + `source = table | where a < 1 | fields a,b,c` + `source = table | where b != 'test' | fields a,b,c` + `source = table | where c = 'test' | fields a,b,c | head 3` + `source = table | where ispresent(b)` + `source = table | where isnull(coalesce(a, b)) | fields a,b,c | head 3` + `source = table | where isempty(a)` + `source = table | where isblank(a)` + `source = table | where case(length(a) > 6, 'True' else 'False') = 'True'` + `source = table | where a not in (1, 2, 3) | fields a,b,c` + `source = table | where a between 1 and 4`- Nota: questo restituisce un >= 1 e un <= 4, cioè [1, 4] + `source = table | where b not between '2024-09-10' and '2025-09-10'`- Nota: restituisce b >= '\$1\$1\$1\$1\$1\$1\$1\$1\$1\$1' e b <= '2025-09-10' + `source = table | where cidrmatch(ip, '***********/24')` + `source = table | where cidrmatch(ipv6, '2003:db8::/32')` + `source = table | trendline sma(2, temperature) as temp_trend` **Interrogazioni relative all'IP** + `source = table | where cidrmatch(ip, '**************')` + `source = table | where isV6 = false and isValid = true and cidrmatch(ipAddress, '**************')` + `source = table | where isV6 = true | eval inRange = case(cidrmatch(ipAddress, '2003:***::/32'), 'in' else 'out') | fields ip, inRange` **Filtri complessi** ``` source = table | eval status_category = case(a >= 200 AND a < 300, 'Success', a >= 300 AND a < 400, 'Redirection', a >= 400 AND a < 500, 'Client Error', a >= 500, 'Server Error' else 'Incorrect HTTP status code') | where case(a >= 200 AND a < 300, 'Success', a >= 300 AND a < 400, 'Redirection', a >= 400 AND a < 500, 'Client Error', a >= 500, 'Server Error' else 'Incorrect HTTP status code' ) = 'Incorrect HTTP status code' ``` ``` source = table | eval factor = case(a > 15, a - 14, isnull(b), a - 7, a < 3, a + 1 else 1) | where case(factor = 2, 'even', factor = 4, 'even', factor = 6, 'even', factor = 8, 'even' else 'odd') = 'even' | stats count() by factor ``` **Filtri con condizioni logiche** + `source = table | where c = 'test' AND a = 1 | fields a,b,c` + `source = table | where c != 'test' OR a > 1 | fields a,b,c | head 1` + `source = table | where c = 'test' NOT a > 1 | fields a,b,c` **Valutazione** Ipotesi:`a`,`b`, `c` sono campi esistenti in `table` + `source = table | eval f = 1 | fields a,b,c,f` + `source = table | eval f = 1`(campi di output a, b, c, f) + `source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t` + `source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5` + `source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h` + `source = table | eval f = a * 2, h = f * 2 | fields a,f,h` + `source = table | eval f = a * 2, h = b | stats avg(f) by h` + `source = table | eval f = ispresent(a)` + `source = table | eval r = coalesce(a, b, c) | fields r` + `source = table | eval e = isempty(a) | fields e` + `source = table | eval e = isblank(a) | fields e` + `source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')` + `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')` + `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))` + `source = table | eval digest = md5(fieldName) | fields digest` + `source = table | eval digest = sha1(fieldName) | fields digest` + `source = table | eval digest = sha2(fieldName,256) | fields digest` + `source = table | eval digest = sha2(fieldName,512) | fields digest` #### comando fillnull **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) **Description** Utilizzate il `fillnull` comando per sostituire i valori nulli con un valore specificato in uno o più campi dei risultati della ricerca. **Sintassi** Utilizzare la seguente sintassi: ``` fillnull [with in ["," ]] | [using = ["," = ]] ``` + null-replacement: obbligatorio. Il valore usato per sostituire i valori nulli. + nullable-field: obbligatorio. Riferimento al campo. I valori nulli in questo campo verranno sostituiti con il valore specificato in null-replacement. **Esempio 1: Riempi un campo** L'esempio mostra come utilizzare fillnull su un singolo campo: ``` os> source=logs | fields status_code | eval input=status_code | fillnull with 0 in status_code; | input | status_code | |-------|-------------| | 403 | 403 | | 403 | 403 | | NULL | 0 | | NULL | 0 | | 200 | 200 | | 404 | 404 | | 500 | 500 | | NULL | 0 | | 500 | 500 | | 404 | 404 | | 200 | 200 | | 500 | 500 | | NULL | 0 | | NULL | 0 | | 404 | 404 | ``` **Esempio 2: Fillnull applicato a più campi** L'esempio mostra fillnull applicato a più campi. ``` os> source=logs | fields request_path, timestamp | eval input_request_path=request_path, input_timestamp = timestamp | fillnull with '???' in request_path, timestamp; | input_request_path | input_timestamp | request_path | timestamp | |------------------------------------------------------------------------------------| | /contact | NULL | /contact | ??? | | /home | NULL | /home | ??? | | /about | 2023-10-01 10:30:00 | /about | 2023-10-01 10:30:00 | | /home | 2023-10-01 10:15:00 | /home | 2023-10-01 10:15:00 | | NULL | 2023-10-01 10:20:00 | ??? | 2023-10-01 10:20:00 | | NULL | 2023-10-01 11:05:00 | ??? | 2023-10-01 11:05:00 | | /about | NULL | /about | ??? | | /home | 2023-10-01 10:00:00 | /home | 2023-10-01 10:00:00 | | /contact | NULL | /contact | ??? | | NULL | 2023-10-01 10:05:00 | ??? | 2023-10-01 10:05:00 | | NULL | 2023-10-01 10:50:00 | ??? | 2023-10-01 10:50:00 | | /services | NULL | /services | ??? | | /home | 2023-10-01 10:45:00 | /home | 2023-10-01 10:45:00 | | /services | 2023-10-01 11:00:00 | /services | 2023-10-01 11:00:00 | | NULL | 2023-10-01 10:35:00 | ??? | 2023-10-01 10:35:00 | ``` **Esempio 3: Fillnull applicato a più campi con vari valori sostitutivi nulli.** L'esempio mostra fillnull con vari valori usati per sostituire i valori null. + `/error`nel `request_path` campo + `1970-01-01 00:00:00`in `timestamp` campo ``` os> source=logs | fields request_path, timestamp | eval input_request_path=request_path, input_timestamp = timestamp | fillnull using request_path = '/error', timestamp='1970-01-01 00:00:00'; | input_request_path | input_timestamp | request_path | timestamp | |------------------------------------------------------------------------------------| | /contact | NULL | /contact | 1970-01-01 00:00:00 | | /home | NULL | /home | 1970-01-01 00:00:00 | | /about | 2023-10-01 10:30:00 | /about | 2023-10-01 10:30:00 | | /home | 2023-10-01 10:15:00 | /home | 2023-10-01 10:15:00 | | NULL | 2023-10-01 10:20:00 | /error | 2023-10-01 10:20:00 | | NULL | 2023-10-01 11:05:00 | /error | 2023-10-01 11:05:00 | | /about | NULL | /about | 1970-01-01 00:00:00 | | /home | 2023-10-01 10:00:00 | /home | 2023-10-01 10:00:00 | | /contact | NULL | /contact | 1970-01-01 00:00:00 | | NULL | 2023-10-01 10:05:00 | /error | 2023-10-01 10:05:00 | | NULL | 2023-10-01 10:50:00 | /error | 2023-10-01 10:50:00 | | /services | NULL | /services | 1970-01-01 00:00:00 | | /home | 2023-10-01 10:45:00 | /home | 2023-10-01 10:45:00 | | /services | 2023-10-01 11:00:00 | /services | 2023-10-01 11:00:00 | | NULL | 2023-10-01 10:35:00 | /error | 2023-10-01 10:35:00 | ``` #### comando fields **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Utilizzate il `fields` comando per mantenere o rimuovere campi dal risultato della ricerca. **Sintassi** Utilizzare la seguente sintassi: ``` field [+|-] ``` + `index`: facoltativo. Se si utilizza il segno più (\$1), verranno conservati solo i campi specificati nell'elenco dei campi. Se si utilizza il segno meno (-), tutti i campi specificati nell'elenco dei campi verranno rimossi. *Impostazione predefinita*: \$1 + `field list`: Obbligatorio. Un elenco di campi delimitati da virgole da conservare o rimuovere. **Esempio 1: Seleziona i campi specificati dal risultato** Questo esempio mostra come recuperare `account_number` `lastname` i campi e dai risultati di ricerca. `firstname` Interrogazione PPL: ``` os> source=accounts | fields account_number, firstname, lastname; fetched rows / total rows = 4/4 +------------------+-------------+------------+ | account_number | firstname | lastname | |------------------+-------------+------------| | 1 | Jane | Doe | | 6 | John | Doe | | 13 | Jorge | Souza | | 18 | Juan | Li | +------------------+-------------+------------+ ``` **Esempio 2: rimuovere i campi specificati dal risultato** Questo esempio mostra come rimuovere il `account_number` campo dai risultati di ricerca. Interrogazione PPL: ``` os> source=accounts | fields account_number, firstname, lastname | fields - account_number ; fetched rows / total rows = 4/4 +-------------+------------+ | firstname | lastname | |-------------+------------| | Jane | Doe | | John | Doe | | Jorge | Souza | | Juan | Li | +-------------+------------+ ``` **Esempi aggiuntivi** + `source = table` + `source = table | fields a,b,c` + `source = table | fields + a,b,c` + `source = table | fields - b,c` + `source = table | eval b1 = b | fields - b1,c` Esempio di campi annidati: ``` `source = catalog.schema.table1, catalog.schema.table2 | fields A.nested1, B.nested1` `source = catalog.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield` `source = catalog.schema.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield` ``` #### comando flatten **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Utilizzate il comando flatten per espandere i campi dei seguenti tipi: + `struct` + `array>` **Sintassi** Utilizzare la seguente sintassi: ``` flatten ``` + *field*: Il campo da appiattire. Il campo deve essere del tipo supportato. **Schema** | nome\$1col | data\$1type | | --- | --- | | \$1ora | stringa | | ponti | matrice | | città | stringa | | colore | struttura | | paese | stringa | **Dati** | \$1tempo | ponti | città | colore | paese | | --- | --- | --- | --- | --- | | 2024-09-13H 12:00:00 | [\$1801, Tower Bridge\$1, \$1928, Ponte di Londra\$1] | Londra | \$135, 51,5074, -0,1278\$1 | Inghilterra | | 2024-09-13H 12:00:00 | [\$1232, Pont Neuf\$1, \$1160, Ponte Alessandro III\$1] | Parigi | \$135, 48,8566, 2,3522\$1 | Francia | | 2024-09-13H 12:00:00 | [\$148, Ponte di Rialto\$1, \$111, Ponte dei Sospiri\$1] | Venezia | \$12, 45.408, 12.315\$1 | Italia | | 2024-09-13H 12:00:00 | [\$1\$1\$1\$1, Ponte Carlo\$1, \$1343, Ponte della Legione\$1] | Praga | \$1200, 50.0755, 14.4378\$1 | Repubblica Ceca | | 2024-09-13H 12:00:00 | [\$1375, Ponte delle Catene\$1, \$1333, Ponte della Libertà\$1] | Budapest | \$196, 47,4979, 19.0402\$1 | Ungheria | | 1990-09-13H 12:00:00 | NULL | Varsavia | NULL | Polonia | **Esempio 1: appiattire la struttura** Questo esempio mostra come appiattire un campo struct. Interrogazione PPL: ``` source=table | flatten coor ``` | \$1ora | ponti | città | paese | alt | Lat | Long | | --- | --- | --- | --- | --- | --- | --- | | 2024-09-13H 12:00:00 | [\$1801, Tower Bridge\$1, \$1928, Ponte di Londra\$1] | Londra | Inghilterra | 35 | 51,5074 | -0,1278 | | 2024-09-13H 12:00:00 | [\$1232, Pont Neuf\$1, \$1160, Ponte Alessandro III\$1] | Parigi | Francia | 35 | 48,8566 | 2,3522 | | 2024-09-13H 12:00:00 | [\$148, Ponte di Rialto\$1, \$111, Ponte dei Sospiri\$1] | Venezia | Italia | 2 | 45.408 | 12,3155 | | 2024-09-13H 12:00:00 | [\$1516, Ponte Carlo\$1, \$1343, Ponte della Legione\$1] | Praga | Repubblica Ceca | 200 | 50.0755 | 14,4378 | | 2024-09-13H 12:00:00 | [\$1375, Ponte delle Catene\$1, \$1333, Ponte della Libertà\$1] | Budapest | Ungheria | 96 | 47,4979 | 19,0402 | | 1990-09-13H 12:00:00 | NULL | Varsavia | Polonia | NULL | NULL | NULL | **Esempio 2: flatten array** L'esempio mostra come appiattire una matrice di campi struct. Interrogazione PPL: ``` source=table | flatten bridges ``` | \$1ora | città | colore | paese | length | nome | | --- | --- | --- | --- | --- | --- | | 2024-09-13H 12:00:00 | Londra | \$135, 51,5074, -0,1278\$1 | Inghilterra | 801 | Tower Bridge | | 2024-09-13H 12:00:00 | Londra | \$135, 51,5074, -0,1278\$1 | Inghilterra | 928 | Ponte di Londra | | 2024-09-13H 12:00:00 | Parigi | \$135, 48,8566, 2,3522\$1 | Francia | 232 | Pont-Neuf | | 2024-09-13H 12:00:00 | Parigi | \$135, 48,8566, 2,3522\$1 | Francia | 160 | Ponte Alessandro III | | 2024-09-13H 12:00:00 | Venezia | \$12, 45.408, 12.315\$1 | Italia | 48 | Ponte di Rialto | | 2024-09-13H 12:00:00 | Venezia | \$12, 45.408, 12.315\$1 | Italia | 11 | Ponte dei Sospiri | | 2024-09-13H 12:00:00 | Praga | \$1200, 50.0755, 14.4378\$1 | Repubblica Ceca | 516 | Ponte Carlo | | 2024-09-13H 12:00:00 | Praga | \$1200, 50.0755, 14.4378\$1 | Repubblica Ceca | 343 | Ponte della Legione | | 2024-09-13H 12:00:00 | Budapest | \$196, 47,4979, 19.0402\$1 | Ungheria | 375 | Ponte delle Catene | | 2024-09-13H 12:00:00 | Budapest | \$196, 47,4979, 19.0402\$1 | Ungheria | 333 | Ponte della Libertà | | 1990-09-13H 12:00:00 | Varsavia | NULL | Polonia | NULL | NULL | **Esempio 3: appiattire l'array e la struttura** Questo esempio mostra come appiattire più campi. Interrogazione PPL: ``` source=table | flatten bridges | flatten coor ``` | \$1ora | città | paese | length | nome | alt | Lat | Long | | --- | --- | --- | --- | --- | --- | --- | --- | | 2024-09-13H 12:00:00 | Londra | Inghilterra | 801 | Tower Bridge | 35 | 51,5074 | -0,1278 | | 2024-09-13H 12:00:00 | Londra | Inghilterra | 928 | Ponte di Londra | 35 | 51,5074 | -0,1278 | | 2024-09-13H 12:00:00 | Parigi | Francia | 232 | Pont-Neuf | 35 | 48,8566 | 2,3522 | | 2024-09-13H 12:00:00 | Parigi | Francia | 160 | Ponte Alessandro III | 35 | 48,8566 | 2,3522 | | 2024-09-13H 12:00:00 | Venezia | Italia | 48 | Ponte di Rialto | 2 | 45,408 | 12,3155 | | 2024-09-13H 12:00:00 | Venezia | Italia | 11 | Ponte dei Sospiri | 2 | 45.408 | 12,3155 | | 2024-09-13H 12:00:00 | Praga | Repubblica Ceca | 516 | Ponte Carlo | 200 | 50,0755 | 14,4378 | | 2024-09-13H 12:00:00 | Praga | Repubblica Ceca | 343 | Ponte della Legione | 200 | 50.0755 | 14,4378 | | 2024-09-13H 12:00:00 | Budapest | Ungheria | 375 | Ponte delle Catene | 96 | 47,4979 | 19,0402 | | 2024-09-13H 12:00:00 | Budapest | Ungheria | 333 | Ponte della Libertà | 96 | 47,4979 | 19,0402 | | 1990-09-13H 12:00:00 | Varsavia | Polonia | NULL | NULL | NULL | NULL | NULL | #### comando grok **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Il `grok` comando analizza un campo di testo con uno schema grok e aggiunge i risultati al risultato della ricerca. **Sintassi** Utilizzare la seguente sintassi: ``` grok ``` **field** + Obbligatorio. + Il campo deve essere un campo di testo. **pattern** + Obbligatorio. + Il modello grok usato per estrarre nuovi campi dal campo di testo specificato. + Se esiste già un nuovo nome di campo, sostituirà il campo originale. **Pattern grok** Il pattern grok viene utilizzato per abbinare il campo di testo di ogni documento per estrarre nuovi campi. **Esempio 1: creare il nuovo campo** Questo esempio mostra come creare un nuovo campo `host` per ogni documento. `host`sarà il nome host dopo `@` nel `email` campo. L'analisi di un campo nullo restituirà una stringa vuota. ``` os> source=accounts | grok email '.+@%{HOSTNAME:host}' | fields email, host ; fetched rows / total rows = 4/4 +-------------------------+-------------+ | email | host | |-------------------------+-------------| | jane_doe@example.com | example.com | | arnav_desai@example.net | example.net | | null | | | juan_li@example.org | example.org | +-------------------------+-------------+ ``` **Esempio 2: sovrascrivi il campo esistente** Questo esempio mostra come sostituire il `address` campo esistente con il numero civico rimosso. ``` os> source=accounts | grok address '%{NUMBER} %{GREEDYDATA:address}' | fields address ; fetched rows / total rows = 4/4 +------------------+ | address | |------------------| | Example Lane | | Any Street | | Main Street | | Example Court | +------------------+ ``` **Esempio 3: Usare grok per analizzare i log** Questo esempio mostra come usare grok per analizzare i log non elaborati. ``` os> source=apache | grok message '%{COMMONAPACHELOG}' | fields COMMONAPACHELOG, timestamp, response, bytes ; fetched rows / total rows = 4/4 +-----------------------------------------------------------------------------------------------------------------------------+----------------------------+------------+---------+ | COMMONAPACHELOG | timestamp | response | bytes | |-----------------------------------------------------------------------------------------------------------------------------+----------------------------+------------+---------| | 177.95.8.74 - upton5450 [28/Sep/2022:10:15:57 -0700] "HEAD /e-business/mindshare HTTP/1.0" 404 19927 | 28/Sep/2022:10:15:57 -0700 | 404 | 19927 | | 127.45.152.6 - pouros8756 [28/Sep/2022:10:15:57 -0700] "GET /architectures/convergence/niches/mindshare HTTP/1.0" 100 28722 | 28/Sep/2022:10:15:57 -0700 | 100 | 28722 | | *************** - - [28/Sep/2022:10:15:57 -0700] "PATCH /strategize/out-of-the-box HTTP/1.0" 401 27439 | 28/Sep/2022:10:15:57 -0700 | 401 | 27439 | | ************** - - [28/Sep/2022:10:15:57 -0700] "POST /users HTTP/1.1" 301 9481 | 28/Sep/2022:10:15:57 -0700 | 301 | 9481 | +-----------------------------------------------------------------------------------------------------------------------------+----------------------------+------------+---------+ ``` **Limitazioni** Il comando grok presenta le stesse limitazioni del comando parse. #### comando head **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Utilizzate il `head` comando per restituire il primo numero N di risultati specificati dopo un offset opzionale nell'ordine di ricerca. **Sintassi** Utilizzare la seguente sintassi: ``` head [] [from ] ``` **** + Numero intero opzionale. + Il numero di risultati da restituire. + Impostazione predefinita: 10 **** + Numero intero dopo facoltativo`from`. + Il numero di risultati da saltare. + Impostazione predefinita: 0 **Esempio 1: ottieni i primi 10 risultati** Questo esempio mostra come recuperare un massimo di 10 risultati dall'indice dei conti. Interrogazione PPL: ``` os> source=accounts | fields firstname, age | head; fetched rows / total rows = 4/4 +-------------+-------+ | firstname | age | |-------------+-------| | Jane | 32 | | John | 36 | | Jorge | 28 | | Juan | 33 | +-------------+-------+ ``` **Esempio 2: ottieni i primi N risultati** L'esempio mostra i primi N risultati dell'indice dei conti. Interrogazione PPL: ``` os> source=accounts | fields firstname, age | head 3; fetched rows / total rows = 3/3 +-------------+-------+ | firstname | age | |-------------+-------| | Jane | 32 | | John | 36 | | Jorge | 28 | +-------------+-------+ ``` **Esempio 3: ottieni i primi N risultati dopo l'offset M** Questo esempio mostra come recuperare i primi N risultati dopo aver saltato M risultati dall'indice dei conti. Interrogazione PPL: ``` os> source=accounts | fields firstname, age | head 3 from 1; fetched rows / total rows = 3/3 +-------------+-------+ | firstname | age | |-------------+-------| | John | 36 | | Jorge | 28 | | Juan | 33 | +-------------+-------+ ``` #### comando join **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Il comando join consente di combinare dati provenienti da più fonti in base a campi comuni, consentendoti di eseguire analisi complesse e ottenere informazioni più approfondite dai set di dati distribuiti **Schema** Esistono almeno due indici, `otel-v1-apm-span-*` (grande) e `otel-v1-apm-service-map` (piccolo). Campi pertinenti degli indici: **`otel-v1-apm-span-*`** + TraceID: un identificatore univoco per una traccia. Tutti gli intervalli della stessa traccia condividono lo stesso traceID. + spanID: un identificatore univoco per uno spazio all'interno di una traccia, assegnato al momento della creazione dello span. + parentSpanId - Lo spanID dello span principale di questo spazio. Se si tratta di uno span principale, questo campo deve essere vuoto. + durationInNanos - La differenza in nanosecondi tra StartTime ed EndTime. (questo è nell'interfaccia utente) `latency` + Servicename: la risorsa da cui proviene lo span. + TraceGroup: il nome dell'estensione principale della traccia. **`otel-v1-apm-service-map`** + ServiceName - Il nome del servizio che ha emesso lo span. + destination.domain - Il ServiceName del servizio chiamato da questo client. + destination.resource - Lo span name (API, operation e così via) chiamato da questo client. + target.domain - Il ServiceName del servizio chiamato da un client. + target.resource - Lo span name (API, operation e così via) chiamato da un client. + traceGroupName - Lo span name di primo livello che ha avviato la catena di richieste. **Requisito** Support **join** per il calcolo di quanto segue: Per ogni servizio, unisci span index all'indice della mappa dei servizi per calcolare le metriche in base a diversi tipi di filtri. Questa query di esempio calcola la latenza quando viene filtrata per gruppo di traccia per il servizio. `client_cancel_order` `order` ``` SELECT avg(durationInNanos) FROM `otel-v1-apm-span-000001` t1 WHERE t1.serviceName = `order` AND ((t1.name in (SELECT target.resource FROM `otel-v1-apm-service-map` WHERE serviceName = `order` AND traceGroupName = `client_cancel_order`) AND t1.parentSpanId != NULL) OR (t1.parentSpanId = NULL AND t1.name = `client_cancel_order`)) AND t1.traceId in (SELECT traceId FROM `otel-v1-apm-span-000001` WHERE serviceName = `order`) ``` **Esegui la migrazione a PPL** Sintassi del comando join ``` SEARCH source= | | [joinType] JOIN [leftAlias] ON joinCriteria | ``` **Riscrittura** ``` SEARCH source=otel-v1-apm-span-000001 | WHERE serviceName = 'order' | JOIN left=t1 right=t2 ON t1.traceId = t2.traceId AND t2.serviceName = 'order' otel-v1-apm-span-000001 -- self inner join | EVAL s_name = t1.name -- rename to avoid ambiguous | EVAL s_parentSpanId = t1.parentSpanId -- RENAME command would be better when it is supported | EVAL s_durationInNanos = t1.durationInNanos | FIELDS s_name, s_parentSpanId, s_durationInNanos -- reduce colunms in join | LEFT JOIN left=s1 right=t3 ON s_name = t3.target.resource AND t3.serviceName = 'order' AND t3.traceGroupName = 'client_cancel_order' otel-v1-apm-service-map | WHERE (s_parentSpanId IS NOT NULL OR (s_parentSpanId IS NULL AND s_name = 'client_cancel_order')) | STATS avg(s_durationInNanos) -- no need to add alias if there is no ambiguous ``` **Tipo di giunto** + Sintassi: `INNER | LEFT OUTER | CROSS` + Facoltativo + Il tipo di join da eseguire. L'impostazione predefinita è `INNER` se non è specificata. **Alias sinistro** + Sintassi: `left = ` + Facoltativo + L'alias della subquery da usare con il lato sinistro del join, per evitare denominazioni ambigue. **JoinCriteria** + Sintassi: `` + Richiesto + La sintassi inizia con. `ON` Potrebbe essere qualsiasi espressione di confronto. In genere, i criteri di unione sono i seguenti`.=.`. Ad esempio: `l.id = r.id`. Se i criteri di unione contengono più condizioni, è possibile specificare `AND` un `OR` operatore tra ogni espressione di confronto. Ad esempio, `l.id = r.id AND l.email = r.email AND (r.age > 65 OR r.age < 18)`. **Altri esempi** Migrazione da una query SQL (TPC-H Q13): ``` SELECT c_count, COUNT(*) AS custdist FROM ( SELECT c_custkey, COUNT(o_orderkey) c_count FROM customer LEFT OUTER JOIN orders ON c_custkey = o_custkey AND o_comment NOT LIKE '%unusual%packages%' GROUP BY c_custkey ) AS c_orders GROUP BY c_count ORDER BY custdist DESC, c_count DESC; ``` Riscritto dalla join query PPL: ``` SEARCH source=customer | FIELDS c_custkey | LEFT OUTER JOIN ON c_custkey = o_custkey AND o_comment NOT LIKE '%unusual%packages%' orders | STATS count(o_orderkey) AS c_count BY c_custkey | STATS count() AS custdist BY c_count | SORT - custdist, - c_count ``` Limitazione: le ricerche secondarie non sono supportate nella parte destra di join. Se le ricerche secondarie sono supportate, è possibile riscrivere la precedente query PPL come segue: ``` SEARCH source=customer | FIELDS c_custkey | LEFT OUTER JOIN ON c_custkey = o_custkey [ SEARCH source=orders | WHERE o_comment NOT LIKE '%unusual%packages%' | FIELDS o_orderkey, o_custkey ] | STATS count(o_orderkey) AS c_count BY c_custkey | STATS count() AS custdist BY c_count | SORT - custdist, - c_count ``` #### comando lookup **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Utilizzate il `lookup` comando per arricchire i dati di ricerca aggiungendo o sostituendo i dati da un indice di ricerca (tabella delle dimensioni). Questo comando consente di estendere i campi di un indice con i valori di una tabella delle dimensioni. È inoltre possibile utilizzarlo per aggiungere o sostituire valori quando vengono soddisfatte le condizioni di ricerca. Il `lookup` comando è più adatto del `Join` comando per arricchire i dati di origine con un set di dati statico. **Sintassi** Utilizzare la seguente sintassi: ``` SEARCH source= | | LOOKUP ( [AS ])... [(REPLACE | APPEND) ( [AS ])...] | ``` **Indice di ricerca** + Obbligatorio. + Il nome dell'indice di ricerca (tabella delle dimensioni). **lookupMappingField** + Obbligatorio. + Una chiave di mappatura nell'indice di ricerca, analoga a una chiave di join della tabella destra. È possibile specificare più campi, separati da virgole. **sourceMappingField** + Opzionale. + Impostazione predefinita: < lookupMappingField >. + Una chiave di mappatura dalla query di origine, analoga a una chiave di unione dal lato sinistro. **Campo di input** + Opzionale. + Predefinito: tutti i campi dell'indice di ricerca in cui vengono trovati i valori corrispondenti. + Un campo dell'indice di ricerca in cui i valori corrispondenti vengono applicati all'output dei risultati. È possibile specificare più campi, separati da virgole. **Campo di output** + Opzionale. + Default: ``. + Un campo nell'output. È possibile specificare più campi di output. Se si specifica un nome di campo esistente dalla query di origine, i relativi valori verranno sostituiti o aggiunti dai valori corrispondenti di InputField. Se si specifica un nuovo nome di campo, questo verrà aggiunto ai risultati. **SOSTITUISCI \$1 AGGIUNGI** + Opzionale. + Predefinito: REPLACE + Specifica come gestire i valori corrispondenti. Se si specifica REPLACE, i valori corrispondenti nel campo sovrascrivono i valori nel risultato. Se si specifica`APPEND`, i valori corrispondenti nel campo vengono aggiunti solo ai valori mancanti nel risultato. **Utilizzo** + LOOKUP id AS cid SOSTITUISCI mail AS email + NOME CERCA SOSTITUISCI mail COME email + ID LOOKUP AS cid, nome AGGIUNGI indirizzo, mail COME email + ID LOOKUP **Esempio** Fare riferimento agli esempi riportati di seguito. ``` SEARCH source= | WHERE orderType = 'Cancelled' | LOOKUP account_list, mkt_id AS mkt_code REPLACE amount, account_name AS name | STATS count(mkt_code), avg(amount) BY name ``` ``` SEARCH source= | DEDUP market_id | EVAL category=replace(category, "-", ".") | EVAL category=ltrim(category, "dvp.") | LOOKUP bounce_category category AS category APPEND classification ``` ``` SEARCH source= | LOOKUP bounce_category category ``` #### comando parse Il `parse` comando analizza un campo di testo con un'espressione regolare e aggiunge il risultato al risultato della ricerca. **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) **Sintassi** Utilizzare la seguente sintassi: ``` parse ``` **`field`** + Obbligatorio. + Il campo deve essere un campo di testo. **`pattern`** + Stringa obbligatoria. + Questo è il modello di espressione regolare usato per estrarre nuovi campi dal campo di testo specificato. + Se esiste già un nuovo nome di campo, sostituirà il campo originale. **Espressione regolare** Il modello di espressione regolare viene utilizzato per abbinare l'intero campo di testo di ogni documento con il motore regex Java. Ogni gruppo di acquisizione denominato nell'espressione diventerà un nuovo `STRING` campo. **Esempio 1: creare un nuovo campo** L'esempio mostra come creare un nuovo campo `host` per ogni documento. `host`sarà il nome host dopo `@` nel `email` campo. L'analisi di un campo nullo restituirà una stringa vuota. Interrogazione PPL: ``` os> source=accounts | parse email '.+@(?.+)' | fields email, host ; fetched rows / total rows = 4/4 +-----------------------+-------------+ | email | host | |-----------------------+-------------| | jane_doe@example.com | example.com | | john_doe@example.net | example.net | | null | | | juan_li@example.org | example.org | +-----------------------+-------------+ ``` **Esempio 2: sovrascrivere un campo esistente** L'esempio mostra come sostituire il `address` campo esistente con il numero civico rimosso. Interrogazione PPL: ``` os> source=accounts | parse address '\d+ (?
.+)' | fields address ; fetched rows / total rows = 4/4 +------------------+ | address | |------------------| | Example Lane | | Example Street | | Example Avenue | | Example Court | +------------------+ ``` **Esempio 3: filtra e ordina per campo analizzato** L'esempio mostra come ordinare i numeri civici che sono superiori a 500 nel `address` campo. Interrogazione PPL: ``` os> source=accounts | parse address '(?\d+) (?.+)' | where cast(streetNumber as int) > 500 | sort num(streetNumber) | fields streetNumber, street ; fetched rows / total rows = 3/3 +----------------+----------------+ | streetNumber | street | |----------------+----------------| | *** | Example Street | | *** | Example Avenue | | 880 | Example Lane | +----------------+----------------+ ``` **Limitazioni** Esistono alcune limitazioni con il comando parse: + I campi definiti da parse non possono essere analizzati nuovamente. Il seguente comando non funzionerà: ``` source=accounts | parse address '\d+ (?.+)' | parse street '\w+ (?\w+)' ``` + I campi definiti da parse non possono essere sovrascritti con altri comandi. `where`non corrisponderà a nessun documento poiché non `street` può essere sovrascritto: ``` source=accounts | parse address '\d+ (?.+)' | eval street='1' | where street='1' ; ``` + Il campo di testo utilizzato da parse non può essere sovrascritto. `street`non verrà analizzato correttamente poiché è stato sovrascritto: `address` ``` source=accounts | parse address '\d+ (?.+)' | eval address='1' ; ``` + I campi definiti da parse non possono essere filtrati o ordinati dopo averli utilizzati nel comando. `stats` `where`nel seguente comando non funzionerà: ``` source=accounts | parse email '.+@(?.+)' | stats avg(age) by host | where host=pyrami.com ; ``` #### comando patterns **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Il `patterns` comando estrae i modelli di registro da un campo di testo e aggiunge i risultati al risultato della ricerca. Il raggruppamento dei log in base ai relativi schemi semplifica l'aggregazione delle statistiche provenienti da grandi volumi di dati di registro per l'analisi e la risoluzione dei problemi. **Sintassi** Utilizzare la seguente sintassi: ``` patterns [new_field=] [pattern=] ``` **new-field-name** + Stringa opzionale. + Questo è il nome del nuovo campo per i modelli estratti. + Il valore predefinito è `patterns_field`. + Se il nome esiste già, sostituirà il campo originale. **pattern** + Stringa opzionale. + Questo è lo schema regex dei caratteri che devono essere filtrati dal campo di testo. + Se assente, lo schema predefinito è costituito da caratteri alfanumerici (). `[a-zA-Z\d]` **field** + Obbligatorio. + Il campo deve essere un campo di testo. **Esempio 1: creare il nuovo campo** L'esempio mostra come utilizzare l'estrazione della punteggiatura `email` per ogni documento. L'analisi di un campo nullo restituirà una stringa vuota. Interrogazione PPL: ``` os> source=accounts | patterns email | fields email, patterns_field ; fetched rows / total rows = 4/4 +-----------------------+------------------+ | email | patterns_field | |-----------------------+------------------| | jane_doe@example.com | @. | | john_doe@example.net | @. | | null | | | juan_li@example.org | @. | +-----------------------+------------------+ ``` **Esempio 2: Estrarre i modelli di registro** L'esempio mostra come estrarre la punteggiatura da un campo di log non elaborato utilizzando i modelli predefiniti. Interrogazione PPL: ``` os> source=apache | patterns message | fields message, patterns_field ; fetched rows / total rows = 4/4 +-----------------------------------------------------------------------------------------------------------------------------+---------------------------------+ | message | patterns_field | |-----------------------------------------------------------------------------------------------------------------------------+---------------------------------| | 177.95.8.74 - upton5450 [28/Sep/2022:10:15:57 -0700] "HEAD /e-business/mindshare HTTP/1.0" 404 19927 | ... - [//::: -] " /-/ /." | | ************ - pouros8756 [28/Sep/2022:10:15:57 -0700] "GET /architectures/convergence/niches/mindshare HTTP/1.0" 100 28722 | ... - [//::: -] " //// /." | | *************** - - [28/Sep/2022:10:15:57 -0700] "PATCH /strategize/out-of-the-box HTTP/1.0" 401 27439 | ... - - [//::: -] " //--- /." | | ************** - - [28/Sep/2022:10:15:57 -0700] "POST /users HTTP/1.1" 301 9481 | ... - - [//::: -] " / /." | +-----------------------------------------------------------------------------------------------------------------------------+---------------------------------+ ``` **Esempio 3: Estrai modelli di log con un modello regex personalizzato** L'esempio mostra come estrarre la punteggiatura da un campo di log non elaborato utilizzando modelli definiti dall'utente. Interrogazione PPL: ``` os> source=apache | patterns new_field='no_numbers' pattern='[0-9]' message | fields message, no_numbers ; fetched rows / total rows = 4/4 +-----------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------+ | message | no_numbers | |-----------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------| | 177.95.8.74 - upton5450 [28/Sep/2022:10:15:57 -0700] "HEAD /e-business/mindshare HTTP/1.0" 404 19927 | ... - upton [/Sep/::: -] "HEAD /e-business/mindshare HTTP/." | | 127.45.152.6 - pouros8756 [28/Sep/2022:10:15:57 -0700] "GET /architectures/convergence/niches/mindshare HTTP/1.0" 100 28722 | ... - pouros [/Sep/::: -] "GET /architectures/convergence/niches/mindshare HTTP/." | | *************** - - [28/Sep/2022:10:15:57 -0700] "PATCH /strategize/out-of-the-box HTTP/1.0" 401 27439 | ... - - [/Sep/::: -] "PATCH /strategize/out-of-the-box HTTP/." | | ************** - - [28/Sep/2022:10:15:57 -0700] "POST /users HTTP/1.1" 301 9481 | ... - - [/Sep/::: -] "POST /users HTTP/." | +-----------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------+ ``` **Limitazione** Il comando patterns presenta le stesse limitazioni del comando parse. #### comando raro **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Utilizzate il `rare` comando per trovare la tupla di valori meno comune di tutti i campi nell'elenco dei campi. **Nota** Vengono restituiti un massimo di 10 risultati per ogni distinta tupla di valori dei campi raggruppati per. **Sintassi** Utilizzare la seguente sintassi: ``` rare [N] [by-clause] rare_approx [N] [by-clause] ``` **elenco di campi** + Obbligatorio. + Un elenco di nomi di campo delimitato da virgole. **clausola secondaria** + Opzionale. + Uno o più campi in base ai quali raggruppare i risultati. **N** + Il numero di risultati da restituire. + Impostazione predefinita: 10 **rare\$1approx** + Il conteggio approssimativo dei campi rari (n) utilizzando la [cardinalità](https://spark.apache.org/docs/latest/sql-ref-functions-builtin.html) stimata mediante l'algoritmo \$1\$1. HyperLogLog **Esempio 1: trova i valori meno comuni in un campo** L'esempio trova il sesso meno comune tra tutti gli account. Interrogazione PPL: ``` os> source=accounts | rare gender; os> source=accounts | rare_approx 10 gender; os> source=accounts | rare_approx gender; fetched rows / total rows = 2/2 +----------+ | gender | |----------| | F | | M | +----------+ ``` **Esempio 2: trova i valori meno comuni organizzati per genere** L'esempio trova l'età minima comune di tutti gli account raggruppati per genere. Interrogazione PPL: ``` os> source=accounts | rare 5 age by gender; os> source=accounts | rare_approx 5 age by gender; fetched rows / total rows = 4/4 +----------+-------+ | gender | age | |----------+-------| | F | 28 | | M | 32 | | M | 33 | | M | 36 | +----------+-------+ ``` #### comando di ridenominazione Usa il `rename` comando per modificare i nomi di uno o più campi nel risultato della ricerca. **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) **Sintassi** Utilizzare la seguente sintassi: ``` rename AS ["," AS ]... ``` **campo sorgente** + Obbligatorio. + Questo è il nome del campo che vuoi rinominare. **campo-destinazione** + Obbligatorio. + Questo è il nome con cui vuoi rinominare. **Esempio 1: Rinomina un campo** Questo esempio mostra come rinominare un singolo campo. Interrogazione PPL: ``` os> source=accounts | rename account_number as an | fields an; fetched rows / total rows = 4/4 +------+ | an | |------| | 1 | | 6 | | 13 | | 18 | +------+ ``` **Esempio 2: rinominare più campi** Questo esempio mostra come rinominare più campi. Interrogazione PPL: ``` os> source=accounts | rename account_number as an, employer as emp | fields an, emp; fetched rows / total rows = 4/4 +------+---------+ | an | emp | |------+---------| | 1 | Pyrami | | 6 | Netagy | | 13 | Quility | | 18 | null | +------+---------+ ``` **Limitazioni** + La sovrascrittura del campo esistente non è supportata: ``` source=accounts | grok address '%{NUMBER} %{GREEDYDATA:address}' | fields address ``` #### comando di ricerca **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Utilizzate il `search` comando per recuperare i documenti da un indice. Il `search` comando può essere utilizzato solo come primo comando in una query PPL. **Sintassi** Utilizzare la seguente sintassi: ``` search source=[:] [boolean-expression] ``` **cerca** + Opzionale. + Parole chiave di ricerca, che possono essere omesse. **indice** + Obbligatorio. + Il comando search deve specificare da quale indice eseguire la ricerca. + Il nome dell'indice può essere preceduto da `:` per le ricerche tra cluster. **espressione bool** + Opzionale. + Qualsiasi espressione che restituisce un valore booleano. **Esempio 1: recupera tutti i dati** L'esempio mostra il recupero di tutto il documento dall'indice degli account. Interrogazione PPL: ``` os> source=accounts; +------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------+ | account_number | firstname | address | balance | gender | city | employer | state | age | email | lastname | |------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------| | 1 | Jorge | *** Any Lane | 39225 | M | Brogan | ExampleCorp | IL | 32 | jane_doe@example.com | Souza | | 6 | John | *** Example Street | 5686 | M | Dante | AnyCorp | TN | 36 | john_doe@example.com | Doe | | 13 | Jane | *** Any Street | ***** | F | Nogal | ExampleCompany | VA | 28 | null | Doe | | 18 | Juan | *** Example Court | 4180 | M | Orick | null | MD | 33 | juan_li@example.org | Li | +------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------+ ``` **Esempio 2: recupera dati con condizione** L'esempio mostra recuperare tutto il documento dall'indice degli account con. Interrogazione PPL: ``` os> SEARCH source=accounts account_number=1 or gender="F"; +------------------+-------------+--------------------+-----------+----------+--------+----------------+---------+-------+-------------------------+------------+ | account_number | firstname | address | balance | gender | city | employer | state | age | email - | lastname | |------------------+-------------+--------------------+-----------+----------+--------+----------------+---------+-------+-------------------------+------------| | 1 | Jorge | *** Any Lane | ***** | M | Brogan | ExampleCorp | IL | 32 | jorge_souza@example.com | Souza | | 13 | Jane | *** Any Street | ***** | F | Nogal | ExampleCompany | VA | 28 | null | Doe | +------------------+-------------+--------------------+-----------+----------+--------+-----------------+---------+-------+------------------------+------------+ ``` #### comando sort Usa il `sort` comando per ordinare i risultati della ricerca in base ai campi specificati. **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) **Sintassi** Utilizzare la seguente sintassi: ``` sort <[+|-] sort-field>... ``` **[\$1\$1-]** + Opzionale. + Il segno più [\$1] indica l'ordine crescente con NULL/MISSING i valori al primo posto. + Il segno meno [-] indica l'ordine decrescente con NULL/MISSING i valori per ultimi. + Predefinito: ordine crescente con NULL/MISSING i valori per primi. **campo di ordinamento** + Obbligatorio. + Il campo utilizzato per l'ordinamento. **Esempio 1: ordina per un campo** L'esempio mostra come ordinare il documento con il campo dell'età in ordine crescente. Interrogazione PPL: ``` os> source=accounts | sort age | fields account_number, age; fetched rows / total rows = 4/4 +------------------+-------+ | account_number | age | |------------------+-------| | 13 | 28 | | 1 | 32 | | 18 | 33 | | 6 | 36 | +------------------+-------+ ``` **Esempio 2: ordina per un campo e restituisci tutti i risultati** L'esempio mostra come ordinare il documento con il campo età in ordine crescente. Interrogazione PPL: ``` os> source=accounts | sort age | fields account_number, age; fetched rows / total rows = 4/4 +------------------+-------+ | account_number | age | |------------------+-------| | 13 | 28 | | 1 | 32 | | 18 | 33 | | 6 | 36 | +------------------+-------+ ``` **Esempio 3: ordina per un campo in ordine decrescente** L'esempio mostra come ordinare il documento con il campo età in ordine decrescente. Interrogazione PPL: ``` os> source=accounts | sort - age | fields account_number, age; fetched rows / total rows = 4/4 +------------------+-------+ | account_number | age | |------------------+-------| | 6 | 36 | | 18 | 33 | | 1 | 32 | | 13 | 28 | +------------------+-------+ ``` **Esempio 4: ordina per più campi** L'esempio mostra come ordinare il documento con il campo genere in ordine crescente e il campo età in ordine decrescente. Interrogazione PPL: ``` os> source=accounts | sort + gender, - age | fields account_number, gender, age; fetched rows / total rows = 4/4 +------------------+----------+-------+ | account_number | gender | age | |------------------+----------+-------| | 13 | F | 28 | | 6 | M | 36 | | 18 | M | 33 | | 1 | M | 32 | +------------------+----------+-------+ ``` **Esempio 5: Ordina per campo e include un valore nullo** L'esempio mostra come ordinare il campo del datore di lavoro in base all'opzione predefinita (ordine crescente e prima null). Il risultato mostra che il valore nullo è nella prima riga. Interrogazione PPL: ``` os> source=accounts | sort employer | fields employer; fetched rows / total rows = 4/4 +------------+ | employer | |------------| | null | | AnyCompany | | AnyCorp | | AnyOrgty | +------------+ ``` #### comando stats Usa il `stats` comando per calcolare l'aggregazione dai risultati della ricerca. **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) **Gestione dei valori NULL/MANCANTI** **Gestione dei valori NULL/MANCANTI** | Funzione | NULL | MANCANTE | | --- | --- | --- | | COUNT | Non contato | Non contato | | SUM | Ignorare | Ignorare | | AVG | Ignorare | Ignorare | | MAX | Ignorare | Ignorare | | MIN | Ignorare | Ignorare | **Sintassi** Utilizzare la seguente sintassi: ``` stats ... [by-clause] ``` **Aggregazione** + Obbligatorio. + Una funzione di aggregazione applicata a un campo. **clausola secondaria** + Opzionale. + Sintassi: `by [span-expression,] [field,]...` + Specifica i campi e le espressioni per il raggruppamento dei risultati dell'aggregazione. La by-clausola consente di raggruppare i risultati dell'aggregazione utilizzando campi ed espressioni. È possibile utilizzare funzioni scalari, funzioni di aggregazione e persino espressioni span per dividere campi specifici in bucket di intervalli uguali. + Predefinito: se `` viene specificato no, il comando stats restituisce una singola riga che rappresenta l'aggregazione sull'intero set di risultati. **espressione spanx** + Facoltativo, al massimo uno. + Sintassi: `span(field_expr, interval_expr)` + L'unità dell'espressione dell'intervallo è l'unità naturale di default. Se il campo è di tipo data e ora e l'intervallo è espresso in date/time unità, è necessario specificare l'unità nell'espressione dell'intervallo. + Ad esempio, suddividendo il `age` campo in secchi per 10 anni, sembra. `span(age, 10)` Per dividere un campo timestamp in intervalli orari, usa. `span(timestamp, 1h)` **Unità di tempo disponibili** | Unità di intervallo di ampiezza | | --- | | millisecondo (ms) | | secondo/i | | minuto (m, distinzione tra maiuscole e minuscole) | | ora (h) | | giorno (d) | | settimana (e) | | mese (M, distinzione tra maiuscole e minuscole) | | trimestre (q) | | anno (y) | **Funzioni di aggregazione** **`COUNT`** Restituisce un conteggio del numero di espr nelle righe recuperate da un'istruzione SELECT. Esempio: ``` os> source=accounts | stats count(); fetched rows / total rows = 1/1 +-----------+ | count() | |-----------| | 4 | +-----------+ ``` **`SUM`** Si usa `SUM(expr)` per restituire la somma di expr. Esempio ``` os> source=accounts | stats sum(age) by gender; fetched rows / total rows = 2/2 +------------+----------+ | sum(age) | gender | |------------+----------| | 28 | F | | 101 | M | +------------+----------+ ``` **`AVG`** Usa `AVG(expr)` per restituire il valore medio di expr. Esempio ``` os> source=accounts | stats avg(age) by gender; fetched rows / total rows = 2/2 +--------------------+----------+ | avg(age) | gender | |--------------------+----------| | 28.0 | F | | 33.666666666666664 | M | +--------------------+----------+ ``` **`MAX`** Usa `MAX(expr)` per restituire il valore massimo di expr. Esempio ``` os> source=accounts | stats max(age); fetched rows / total rows = 1/1 +------------+ | max(age) | |------------| | 36 | +------------+ ``` **`MIN`** Usa `MIN(expr)` per restituire il valore minimo di expr. Esempio ``` os> source=accounts | stats min(age); fetched rows / total rows = 1/1 +------------+ | min(age) | |------------| | 28 | +------------+ ``` **`STDDEV_SAMP`** Si usa `STDDEV_SAMP(expr)` per restituire la deviazione standard campionaria di expr. Esempio: ``` os> source=accounts | stats stddev_samp(age); fetched rows / total rows = 1/1 +--------------------+ | stddev_samp(age) | |--------------------| | 3.304037933599835 | +--------------------+ ``` **STDDEV\$1POP** Utilizzare `STDDEV_POP(expr)` per restituire la deviazione standard della popolazione di expr. Esempio: ``` os> source=accounts | stats stddev_pop(age); fetched rows / total rows = 1/1 +--------------------+ | stddev_pop(age) | |--------------------| | 2.**************** | +--------------------+ ``` **AFFERRARE** Si usa `TAKE(field [, size])` per restituire i valori originali di un campo. Non garantisce l'ordine dei valori. **field** + Obbligatorio. + Il campo deve essere un campo di testo. **formato** + Numero intero opzionale. + Il numero di valori deve essere restituito. + L'impostazione predefinita è 10. **Esempio** ``` os> source=accounts | stats take(firstname); fetched rows / total rows = 1/1 +-----------------------------+ | take(firstname) | |-----------------------------| | [Jane, Mary, Nikki, Juan | +-----------------------------+ ``` **PERCENTILE o PERCENTILE\$1APPROX** Usa `PERCENTILE(expr, percent)` o `PERCENTILE_APPROX(expr, percent)` per restituire il valore percentile approssimativo di expr alla percentuale specificata. **percentuale** + Il numero deve essere una costante compresa tra 0 e 100. **Esempio** ``` os> source=accounts | stats percentile(age, 90) by gender; fetched rows / total rows = 2/2 +-----------------------+----------+ | percentile(age, 90) | gender | |-----------------------+----------| | 28 | F | | 36 | M | +-----------------------+----------+ ``` **Esempio 1: calcola il conteggio degli eventi** L'esempio mostra come calcolare il conteggio degli eventi nei conti. ``` os> source=accounts | stats count(); fetched rows / total rows = 1/1 +-----------+ | count() | |-----------| | 4 | +-----------+ ``` **Esempio 2: calcola la media di un campo** L'esempio mostra come calcolare l'età media per tutti gli account. ``` os> source=accounts | stats avg(age); fetched rows / total rows = 1/1 +------------+ | avg(age) | |------------| | 32.25 | +------------+ ``` **Esempio 3: calcola la media di un campo per gruppo** L'esempio mostra come calcolare l'età media per tutti gli account, raggruppati per sesso. ``` os> source=accounts | stats avg(age) by gender; fetched rows / total rows = 2/2 +--------------------+----------+ | avg(age) | gender | |--------------------+----------| | 28.0 | F | | 33.666666666666664 | M | +--------------------+----------+ ``` **Esempio 4: calcola la media, la somma e il conteggio di un campo per gruppo** L'esempio mostra come calcolare l'età media, la somma dell'età e il conteggio degli eventi per tutti gli account, raggruppati per sesso. ``` os> source=accounts | stats avg(age), sum(age), count() by gender; fetched rows / total rows = 2/2 +--------------------+------------+-----------+----------+ | avg(age) | sum(age) | count() | gender | |--------------------+------------+-----------+----------| | 28.0 | 28 | 1 | F | | 33.666666666666664 | 101 | 3 | M | +--------------------+------------+-----------+----------+ ``` **Esempio 5: calcola il massimo di un campo** L'esempio calcola l'età massima per tutti gli account. ``` os> source=accounts | stats max(age); fetched rows / total rows = 1/1 +------------+ | max(age) | |------------| | 36 | +------------+ ``` **Esempio 6: calcola il massimo e il minimo di un campo per gruppo** L'esempio calcola i valori di età massima e minima per tutti gli account, raggruppati per sesso. ``` os> source=accounts | stats max(age), min(age) by gender; fetched rows / total rows = 2/2 +------------+------------+----------+ | max(age) | min(age) | gender | |------------+------------+----------| | 28 | 28 | F | | 36 | 32 | M | +------------+------------+----------+ ``` **Esempio 7: calcola il conteggio distinto di un campo** Per ottenere il conteggio dei valori distinti di un campo, puoi usare la funzione `DISTINCT_COUNT` (or`DC`) invece di`COUNT`. L'esempio calcola sia il campo di conteggio che quello di conteggio distinto per genere di tutti gli account. ``` os> source=accounts | stats count(gender), distinct_count(gender); fetched rows / total rows = 1/1 +-----------------+--------------------------+ | count(gender) | distinct_count(gender) | |-----------------+--------------------------| | 4 | 2 | +-----------------+--------------------------+ ``` **Esempio 8: calcola il conteggio in base a un intervallo** L'esempio ottiene il conteggio dell'età per un intervallo di 10 anni. ``` os> source=accounts | stats count(age) by span(age, 10) as age_span fetched rows / total rows = 2/2 +--------------+------------+ | count(age) | age_span | |--------------+------------| | 1 | 20 | | 3 | 30 | +--------------+------------+ ``` **Esempio 9: calcola il conteggio in base al sesso e all'intervallo** Questo esempio conta i record raggruppati per sesso e intervalli di età di 5 anni. ``` os> source=accounts | stats count() as cnt by span(age, 5) as age_span, gender fetched rows / total rows = 3/3 +-------+------------+----------+ | cnt | age_span | gender | |-------+------------+----------| | 1 | 25 | F | | 2 | 30 | M | | 1 | 35 | M | +-------+------------+----------+ ``` L'espressione span appare sempre come prima chiave di raggruppamento, indipendentemente dall'ordine specificato nel comando. ``` os> source=accounts | stats count() as cnt by gender, span(age, 5) as age_span fetched rows / total rows = 3/3 +-------+------------+----------+ | cnt | age_span | gender | |-------+------------+----------| | 1 | 25 | F | | 2 | 30 | M | | 1 | 35 | M | +-------+------------+----------+ ``` **Esempio 10: calcola il conteggio e ottieni l'elenco di e-mail in base al sesso e all'intervallo** L'esempio ottiene il conteggio dell'età per l'intervallo di 10 anni e il gruppo per sesso, inoltre per ogni riga ottieni un elenco di al massimo 5 email. ``` os> source=accounts | stats count() as cnt, take(email, 5) by span(age, 5) as age_span, gender fetched rows / total rows = 3/3 +-------+----------------------------------------------------+------------+----------+ | cnt | take(email, 5) | age_span | gender | |-------+----------------------------------------------------+------------+----------| | 1 | [] | 25 | F | | 2 | [janedoe@anycompany.com,juanli@examplecompany.org] | 30 | M | | 1 | [marymajor@examplecorp.com] | 35 | M | +-------+----------------------------------------------------+------------+----------+ ``` **Esempio 11: calcola il percentile di un campo** L'esempio mostra come calcolare il percentile di 90° età di tutti gli account. ``` os> source=accounts | stats percentile(age, 90); fetched rows / total rows = 1/1 +-----------------------+ | percentile(age, 90) | |-----------------------| | 36 | +-----------------------+ ``` **Esempio 12: calcola il percentile di un campo per gruppo** L'esempio mostra come calcolare il percentile di 90° età di tutti i gruppi di account per sesso. ``` os> source=accounts | stats percentile(age, 90) by gender; fetched rows / total rows = 2/2 +-----------------------+----------+ | percentile(age, 90) | gender | |-----------------------+----------| | 28 | F | | 36 | M | +-----------------------+----------+ ``` **Esempio 13: calcola il percentile in base al sesso e all'intervallo** L'esempio ottiene il percentile di 90° età per intervallo di 10 anni e il gruppo per sesso. ``` os> source=accounts | stats percentile(age, 90) as p90 by span(age, 10) as age_span, gender fetched rows / total rows = 2/2 +-------+------------+----------+ | p90 | age_span | gender | |-------+------------+----------| | 28 | 20 | F | | 36 | 30 | M | +-------+------------+----------+ ``` ``` - `source = table | stats avg(a) ` - `source = table | where a < 50 | stats avg(c) ` - `source = table | stats max(c) by b` - `source = table | stats count(c) by b | head 5` - `source = table | stats distinct_count(c)` - `source = table | stats stddev_samp(c)` - `source = table | stats stddev_pop(c)` - `source = table | stats percentile(c, 90)` - `source = table | stats percentile_approx(c, 99)` ``` **Aggregazioni con span** ``` - `source = table | stats count(a) by span(a, 10) as a_span` - `source = table | stats sum(age) by span(age, 5) as age_span | head 2` - `source = table | stats avg(age) by span(age, 20) as age_span, country | sort - age_span | head 2` ``` **Aggregazioni con timewindow span (funzione tumble windowing)** ``` - `source = table | stats sum(productsAmount) by span(transactionDate, 1d) as age_date | sort age_date` - `source = table | stats sum(productsAmount) by span(transactionDate, 1w) as age_date, productId` ``` **Le aggregazioni sono raggruppate per più livelli** ``` - `source = table | stats avg(age) as avg_state_age by country, state | stats avg(avg_state_age) as avg_country_age by country` - `source = table | stats avg(age) as avg_city_age by country, state, city | eval new_avg_city_age = avg_city_age - 1 | stats avg(new_avg_city_age) as avg_state_age by country, state | where avg_state_age > 18 | stats avg(avg_state_age) as avg_adult_country_age by country` ``` #### comando subquery **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Utilizzate il `subquery` comando per eseguire query complesse e annidate all'interno delle istruzioni PPL (Piped Processing Language). ``` source=logs | where field in [ subquery source=events | where condition | fields field ] ``` In questo esempio, la ricerca primaria (`source=logs`) viene filtrata in base ai risultati della subquery (). `source=events` Il comando subquery supporta più livelli di annidamento per l'analisi di dati complessi. **Esempio di subquery annidata** ``` source=logs | where id in [ subquery source=users | where user in [ subquery source=actions | where action="login" | fields user] | fields uid ] ``` **InSubquery Utilizzo** + `source = outer | where a in [ source = inner | fields b ]` + `source = outer | where (a) in [ source = inner | fields b ]` + `source = outer | where (a,b,c) in [ source = inner | fields d,e,f ]` + `source = outer | where a not in [ source = inner | fields b ]` + `source = outer | where (a) not in [ source = inner | fields b ]` + `source = outer | where (a,b,c) not in [ source = inner | fields d,e,f ]` + `source = outer a in [ source = inner | fields b ]`(filtro di ricerca con sottoquery) + `source = outer a not in [ source = inner | fields b ]`(filtro di ricerca con subquery) + `source = outer | where a in [ source = inner1 | where b not in [ source = inner2 | fields c ] | fields b ]`(annidato) + `source = table1 | inner join left = l right = r on l.a = r.a AND r.a in [ source = inner | fields d ] | fields l.a, r.a, b, c`(come filtro di unione) **Esempi di migrazione SQL con In-Subquery PPL** TPC-H Q4 (nella subquery con aggregazione) ``` select o_orderpriority, count(*) as order_count from orders where o_orderdate >= date '1993-07-01' and o_orderdate < date '1993-07-01' + interval '3' month and o_orderkey in ( select l_orderkey from lineitem where l_commitdate < l_receiptdate ) group by o_orderpriority order by o_orderpriority ``` Riscritto da InSubquery una query PPL: ``` source = orders | where o_orderdate >= "1993-07-01" and o_orderdate < "1993-10-01" and o_orderkey IN [ source = lineitem | where l_commitdate < l_receiptdate | fields l_orderkey ] | stats count(1) as order_count by o_orderpriority | sort o_orderpriority | fields o_orderpriority, order_count ``` TPC-H Q20 (annidato nella sottoquery) ``` select s_name, s_address from supplier, nation where s_suppkey in ( select ps_suppkey from partsupp where ps_partkey in ( select p_partkey from part where p_name like 'forest%' ) ) and s_nationkey = n_nationkey and n_name = 'CANADA' order by s_name ``` Riscritto da una query PPL: InSubquery ``` source = supplier | where s_suppkey IN [ source = partsupp | where ps_partkey IN [ source = part | where like(p_name, "forest%") | fields p_partkey ] | fields ps_suppkey ] | inner join left=l right=r on s_nationkey = n_nationkey and n_name = 'CANADA' nation | sort s_name ``` **ExistsSubquery utilizzo** Ipotesi:`a`, `b` sono campi della tabella esterna`c`, `d` sono campi della tabella interna`e`, `f` sono campi della tabella inner2. + `source = outer | where exists [ source = inner | where a = c ]` + `source = outer | where not exists [ source = inner | where a = c ]` + `source = outer | where exists [ source = inner | where a = c and b = d ]` + `source = outer | where not exists [ source = inner | where a = c and b = d ]` + `source = outer exists [ source = inner | where a = c ]`(filtro di ricerca con sottoquery) + `source = outer not exists [ source = inner | where a = c ]`(filtro di ricerca con subquery) + `source = table as t1 exists [ source = table as t2 | where t1.a = t2.a ]`(L'alias della tabella è utile nella sottoquery exists) + `source = outer | where exists [ source = inner1 | where a = c and exists [ source = inner2 | where c = e ] ]`(annidato) + `source = outer | where exists [ source = inner1 | where a = c | where exists [ source = inner2 | where c = e ] ]`(annidato) + `source = outer | where exists [ source = inner | where c > 10 ]`(esiste una correlazione non correlata) + `source = outer | where not exists [ source = inner | where c > 10 ]`(esiste una correlazione non correlata) + `source = outer | where exists [ source = inner ] | eval l = "nonEmpty" | fields l`(esistono elementi non correlati speciali) **ScalarSubquery utilizzo** Presupposti:`a`, `b` sono campi della tabella esterni`c`, `d` sono campi della tabella interna`e`, `f` sono campi della tabella annidati **Sottoquery scalare non correlata** In Seleziona: + `source = outer | eval m = [ source = inner | stats max(c) ] | fields m, a` + `source = outer | eval m = [ source = inner | stats max(c) ] + b | fields m, a` In dove: + `source = outer | where a > [ source = inner | stats min(c) ] | fields a` Nel filtro di ricerca: + `source = outer a > [ source = inner | stats min(c) ] | fields a` **Sottoquery scalare correlata** In Seleziona: + `source = outer | eval m = [ source = inner | where outer.b = inner.d | stats max(c) ] | fields m, a` + `source = outer | eval m = [ source = inner | where b = d | stats max(c) ] | fields m, a` + `source = outer | eval m = [ source = inner | where outer.b > inner.d | stats max(c) ] | fields m, a` In dove: + `source = outer | where a = [ source = inner | where outer.b = inner.d | stats max(c) ]` + `source = outer | where a = [ source = inner | where b = d | stats max(c) ]` + `source = outer | where [ source = inner | where outer.b = inner.d OR inner.d = 1 | stats count() ] > 0 | fields a` Nel filtro di ricerca: + `source = outer a = [ source = inner | where b = d | stats max(c) ]` + `source = outer [ source = inner | where outer.b = inner.d OR inner.d = 1 | stats count() ] > 0 | fields a` **Sottoquery scalare annidata** + `source = outer | where a = [ source = inner | stats max(c) | sort c ] OR b = [ source = inner | where c = 1 | stats min(d) | sort d ]` + `source = outer | where a = [ source = inner | where c = [ source = nested | stats max(e) by f | sort f ] | stats max(d) by c | sort c | head 1 ]` **(Relazione) Sottoquery** `InSubquery`, `ExistsSubquery` e `ScalarSubquery` sono tutte espressioni di sottoquery. Ma non `RelationSubquery` è un'espressione di sottoquery, è un piano di sottoquery che è comunemente usato nella clausola Join o From. + `source = table1 | join left = l right = r [ source = table2 | where d > 10 | head 5 ]`(subquery nella parte destra di join) + `source = [ source = table1 | join left = l right = r [ source = table2 | where d > 10 | head 5 ] | stats count(a) by b ] as outer | head 1` **Contesto aggiuntivo** `InSubquery``ExistsSubquery`, e `ScalarSubquery` sono espressioni di sottoquery comunemente utilizzate nelle `where` clausole e nei filtri di ricerca. Comando Where: ``` | where | ... ``` Filtro di ricerca: ``` search source=* | ... ``` Un'espressione di sottoquery può essere utilizzata in un'espressione booleana: ``` | where orders.order_id in [ source=returns | where return_reason="damaged" | field order_id ] ``` Il `orders.order_id in [ source=... ]` è un. `` In generale, chiamiamo questo tipo di clausola di sottoquery espressione. `InSubquery` È un. `` **Sottoquery con diversi tipi di join** Esempio utilizzando un `ScalarSubquery`: ``` source=employees | join source=sales on employees.employee_id = sales.employee_id | where sales.sale_amount > [ source=targets | where target_met="true" | fields target_value ] ``` A differenza di InSubquery ExistsSubquery, e ScalarSubquery, a non RelationSubquery è un'espressione di sottoquery. Si tratta invece di un piano di subquery. ``` SEARCH source=customer | FIELDS c_custkey | LEFT OUTER JOIN left = c, right = o ON c.c_custkey = o.o_custkey [ SEARCH source=orders | WHERE o_comment NOT LIKE '%unusual%packages%' | FIELDS o_orderkey, o_custkey ] | STATS ... ``` #### comando top **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Utilizzate il `top` comando per trovare la tupla di valori più comune di tutti i campi nell'elenco dei campi. **Sintassi** Utilizzare la seguente sintassi: ``` top [N] [by-clause] top_approx [N] [by-clause] ``` **N** + Il numero di risultati da restituire. + Impostazione predefinita: 10 **elenco di campi** + Obbligatorio. + Un elenco di nomi di campo delimitato da virgole. **clausola secondaria** + Opzionale. + Uno o più campi in base ai quali raggruppare i risultati. **top\$1approx** + Un conteggio approssimativo dei campi (n) principali utilizzando la [cardinalità stimata mediante l'algoritmo \$1\$1](https://spark.apache.org/docs/latest/sql-ref-functions-builtin.html). HyperLogLog **Esempio 1: trova i valori più comuni in un campo** L'esempio trova il sesso più comune per tutti gli account. Interrogazione PPL: ``` os> source=accounts | top gender; os> source=accounts | top_approx gender; fetched rows / total rows = 2/2 +----------+ | gender | |----------| | M | | F | +----------+ ``` **Esempio 2: trova i valori più comuni in un campo (limitato a 1)** L'esempio individua il genere singolo più comune per tutti gli account. Interrogazione PPL: ``` os> source=accounts | top_approx 1 gender; fetched rows / total rows = 1/1 +----------+ | gender | |----------| | M | +----------+ ``` **Esempio 3: trova i valori più comuni, raggruppati per genere** L'esempio trova l'età più comune per tutti gli account, raggruppati per sesso. Interrogazione PPL: ``` os> source=accounts | top 1 age by gender; os> source=accounts | top_approx 1 age by gender; fetched rows / total rows = 2/2 +----------+-------+ | gender | age | |----------+-------| | F | 28 | | M | 32 | +----------+-------+ ``` #### comando trendline **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Utilizzate il `trendline` comando per calcolare le medie mobili dei campi. **Sintassi** Utilizzate la seguente sintassi ``` TRENDLINE [sort <[+|-] sort-field>] SMA(number-of-datapoints, field) [AS alias] [SMA(number-of-datapoints, field) [AS alias]]... ``` **[\$1\$1-]** + Opzionale. + Il segno più [\$1] indica l'ordine crescente con NULL/MISSING i valori al primo posto. + Il segno meno [-] indica l'ordine decrescente con NULL/MISSING i valori per ultimi. + Predefinito: ordine crescente con NULL/MISSING i valori per primi. **campo di ordinamento** + Obbligatorio quando si utilizza l'ordinamento. + Il campo utilizzato per l'ordinamento. **number-of-datapoints** + Obbligatorio. + Il numero di punti dati che calcolano la media mobile. + Deve essere maggiore di zero. **field** + Obbligatorio. + Il nome del campo per cui deve essere calcolata la media mobile. **alias** + Opzionale. + Il nome della colonna risultante contenente la media mobile. È supportato solo il tipo Simple Moving Average (SMA). Viene calcolato in questo modo: ``` f[i]: The value of field 'f' in the i-th data-point n: The number of data-points in the moving window (period) t: The current time index SMA(t) = (1/n) * Σ(f[i]), where i = t-n+1 to t ``` **Esempio 1: calcola la media mobile semplice per una serie temporale di temperature** L'esempio calcola la media mobile semplice rispetto alle temperature utilizzando due punti dati. Interrogazione PPL: ``` os> source=t | trendline sma(2, temperature) as temp_trend; fetched rows / total rows = 5/5 +-----------+---------+--------------------+----------+ |temperature|device-id| timestamp|temp_trend| +-----------+---------+--------------------+----------+ | 12| 1492|2023-04-06 17:07:...| NULL| | 12| 1492|2023-04-06 17:07:...| 12.0| | 13| 256|2023-04-06 17:07:...| 12.5| | 14| 257|2023-04-06 17:07:...| 13.5| | 15| 258|2023-04-06 17:07:...| 14.5| +-----------+---------+--------------------+----------+ ``` **Esempio 2: calcola medie mobili semplici per una serie temporale di temperature con ordinamento** L'esempio calcola due medie mobili semplici sulle temperature utilizzando due e tre punti dati ordinati in modo decrescente per device-id. Interrogazione PPL: ``` os> source=t | trendline sort - device-id sma(2, temperature) as temp_trend_2 sma(3, temperature) as temp_trend_3; fetched rows / total rows = 5/5 +-----------+---------+--------------------+------------+------------------+ |temperature|device-id| timestamp|temp_trend_2| temp_trend_3| +-----------+---------+--------------------+------------+------------------+ | 15| 258|2023-04-06 17:07:...| NULL| NULL| | 14| 257|2023-04-06 17:07:...| 14.5| NULL| | 13| 256|2023-04-06 17:07:...| 13.5| 14.0| | 12| 1492|2023-04-06 17:07:...| 12.5| 13.0| | 12| 1492|2023-04-06 17:07:...| 12.0|12.333333333333334| +-----------+---------+--------------------+------------+------------------+ ``` #### comando where **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Il `where` comando utilizza un'espressione bool per filtrare i risultati della ricerca. Restituisce il risultato solo quando bool-expression restituisce true. **Sintassi** Utilizzare la seguente sintassi: ``` where ``` **espressione bool** + Opzionale. + Qualsiasi espressione che possa essere valutata in base a un valore booleano. **Esempio 1: filtra il set di risultati con condizione** L'esempio mostra come recuperare dall'indice degli account i documenti che soddisfano condizioni specifiche. Interrogazione PPL: ``` os> source=accounts | where account_number=1 or gender="F" | fields account_number, gender; fetched rows / total rows = 2/2 +------------------+----------+ | account_number | gender | |------------------+----------| | 1 | M | | 13 | F | +------------------+----------+ ``` **Esempi aggiuntivi** **Filtri con condizioni logiche** + `source = table | where c = 'test' AND a = 1 | fields a,b,c` + `source = table | where c != 'test' OR a > 1 | fields a,b,c | head 1` + `source = table | where c = 'test' NOT a > 1 | fields a,b,c` + `source = table | where a = 1 | fields a,b,c` + `source = table | where a >= 1 | fields a,b,c` + `source = table | where a < 1 | fields a,b,c` + `source = table | where b != 'test' | fields a,b,c` + `source = table | where c = 'test' | fields a,b,c | head 3` + `source = table | where ispresent(b)` + `source = table | where isnull(coalesce(a, b)) | fields a,b,c | head 3` + `source = table | where isempty(a)` + `source = table | where isblank(a)` + `source = table | where case(length(a) > 6, 'True' else 'False') = 'True'` + `source = table | where a between 1 and 4`- Nota: questo restituisce un >= 1 e un <= 4, cioè [1, 4] + `source = table | where b not between '2024-09-10' and '2025-09-10'`- Nota: restituisce b >= '\$1\$1\$1\$1\$1\$1\$1\$1\$1\$1' e b <= '2025-09-10' + `source = table | where cidrmatch(ip, '***********/24')` + `source = table | where cidrmatch(ipv6, '2003:db8::/32')` ``` source = table | eval status_category = case(a >= 200 AND a < 300, 'Success', a >= 300 AND a < 400, 'Redirection', a >= 400 AND a < 500, 'Client Error', a >= 500, 'Server Error' else 'Incorrect HTTP status code') | where case(a >= 200 AND a < 300, 'Success', a >= 300 AND a < 400, 'Redirection', a >= 400 AND a < 500, 'Client Error', a >= 500, 'Server Error' else 'Incorrect HTTP status code' ) = 'Incorrect HTTP status code' ``` ``` source = table | eval factor = case(a > 15, a - 14, isnull(b), a - 7, a < 3, a + 1 else 1) | where case(factor = 2, 'even', factor = 4, 'even', factor = 6, 'even', factor = 8, 'even' else 'odd') = 'even' | stats count() by factor ``` #### riepilogo del campo **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands) Utilizzate il `fieldsummary` comando per calcolare le statistiche di base per ogni campo (count, distinct count, min, max, avg, stddev, mean) e determinare il tipo di dati di ogni campo. Questo comando può essere usato con qualsiasi pipe precedente e ne terrà conto. **Sintassi** Utilizzare la seguente sintassi. Per i casi d'uso di CloudWatch Logs, è supportato solo un campo in una query. ``` ... | fieldsummary (nulls=true/false) ``` **includere campi** + Elenco di tutte le colonne da raccogliere con le statistiche in un set di risultati unificato. **Nulls** + Opzionale. + Se impostato su true, includi i valori nulli nei calcoli di aggregazione (sostituisci null con zero per i valori numerici). **Esempio 1** Interrogazione PPL: ``` os> source = t | where status_code != 200 | fieldsummary includefields= status_code nulls=true +------------------+-------------+------------+------------+------------+------------+------------+------------+----------------| | Fields | COUNT | COUNT_DISTINCT | MIN | MAX | AVG | MEAN | STDDEV | NUlls | TYPEOF | |------------------+-------------+------------+------------+------------+------------+------------+------------+----------------| | "status_code" | 2 | 2 | 301 | 403 | 352.0 | 352.0 | 72.12489168102785 | 0 | "int" | +------------------+-------------+------------+------------+------------+------------+------------+------------+----------------| ``` **Esempio 2** Interrogazione PPL: ``` os> source = t | fieldsummary includefields= id, status_code, request_path nulls=true +------------------+-------------+------------+------------+------------+------------+------------+------------+----------------| | Fields | COUNT | COUNT_DISTINCT | MIN | MAX | AVG | MEAN | STDDEV | NUlls | TYPEOF | |------------------+-------------+------------+------------+------------+------------+------------+------------+----------------| | "id" | 6 | 6 | 1 | 6 | 3.5 | 3.5 | 1.8708286933869707 | 0 | "int" | +------------------+-------------+------------+------------+------------+------------+------------+------------+----------------| | "status_code" | 4 | 3 | 200 | 403 | 184.0 | 184.0 | 161.16699413961905 | 2 | "int" | +------------------+-------------+------------+------------+------------+------------+------------+------------+----------------| | "request_path" | 2 | 2 | /about| /home | 0.0 | 0.0 | 0 | 2 |"string"| +------------------+-------------+------------+------------+------------+------------+------------+------------+----------------| ``` #### comando expand **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions) Utilizzate il `expand` comando per appiattire un campo di tipo Array o Map, producendo righe singole per ogni elemento o coppia chiave-valore. **Sintassi** Utilizzare la seguente sintassi: ``` expand [As alias] ``` **field** + Il campo da espandere (esplodere). + Il campo deve essere di un tipo supportato. **alias** + Opzionale. + Il nome da utilizzare al posto del nome del campo originale. **Linee guida per l'utilizzo** Il comando expand produce una riga per ogni elemento nell'array o nel campo della mappa specificato, dove: + Gli elementi dell'array diventano righe singole. + Le coppie chiave-valore della mappa sono suddivise in righe separate, con ogni valore chiave rappresentato come una riga. + Quando viene fornito un alias, i valori esplosi vengono rappresentati sotto l'alias anziché nel nome del campo originale. È possibile utilizzare questo comando in combinazione con altri comandi, come stats, eval e parse, per manipolare o estrarre i dati dopo l'espansione. **Esempi** + `source = table | expand employee | stats max(salary) as max by state, company ` + `source = table | expand employee as worker | stats max(salary) as max by state, company ` + `source = table | expand employee as worker | eval bonus = salary * 3 | fields worker, bonus` + `source = table | expand employee | parse description '(?.+@.+)' | fields employee, email` + `source = table | eval array=json_array(1, 2, 3) | expand array as uid | fields name, occupation, uid ` + `source = table | expand multi_valueA as multiA | expand multi_valueB as multiB` È possibile utilizzare il comando expand in combinazione con altri comandi come eval, stats e altri. L'utilizzo di più comandi di espansione creerà un prodotto cartesiano di tutti gli elementi interni all'interno di ogni matrice o mappa composita. **Query push-down SQL efficace** Il comando expand viene tradotto in un'operazione SQL equivalente utilizzando LATERAL VIEW explode, che consente l'esplosione efficiente di array o mappe a livello di query SQL. ``` SELECT customer exploded_productId FROM table LATERAL VIEW explode(productId) AS exploded_productId ``` Il comando explode offre le seguenti funzionalità: + È un'operazione su colonna che restituisce una nuova colonna. + Crea una nuova riga per ogni elemento nella colonna esplosa. + I valori null interni vengono ignorati come parte del campo esploso (nessuna riga indica null). created/exploded #### Funzioni PPL **Topics** + [Funzioni di condizione PPL](#supported-ppl-condition-functions) + [funzioni hash crittografiche PPL](#supported-ppl-cryptographic-functions) + [Funzioni di data e ora PPL](#supported-ppl-date-time-functions) + [espressioni PPL](#supported-ppl-expressions) + [Funzioni degli indirizzi IP PPL](#supported-ppl-ip-address-functions) + [Funzioni PPL JSON](#supported-ppl-json-functions) + [Funzioni PPL Lambda](#supported-ppl-lambda-functions) + [Funzioni matematiche PPL](#supported-ppl-math-functions) + [Funzioni di stringa PPL](#supported-ppl-string-functions) + [Funzioni di conversione di tipo PPL](#supported-ppl-type-conversion-functions) ##### Funzioni di condizione PPL **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions) ##### ISNULL **Descrizione**: `isnull(field)` restituisce true se il campo è nullo. **Tipo di argomento:** + Tutti i tipi di dati supportati. **Tipo di restituzione:** + BOOLEAN **Esempio**: ``` os> source=accounts | eval result = isnull(employer) | fields result, employer, firstname fetched rows / total rows = 4/4 +----------+-------------+-------------+ | result | employer | firstname | |----------+-------------+-------------| | False | AnyCompany | Mary | | False | ExampleCorp | Jane | | False | ExampleOrg | Nikki | | True | null | Juan | +----------+-------------+-------------+ ``` ##### NON È NULLO **Descrizione**: `isnotnull(field)` restituisce true se il campo non è nullo. **Tipo di argomento:** + Tutti i tipi di dati supportati. **Tipo di restituzione:** + BOOLEAN **Esempio**: ``` os> source=accounts | where not isnotnull(employer) | fields account_number, employer fetched rows / total rows = 1/1 +------------------+------------+ | account_number | employer | |------------------+------------| | 18 | null | +------------------+------------+ ``` ##### EXISTS **Esempio**: ``` os> source=accounts | where exists(email) | fields account_number, email fetched rows / total rows = 1/1 ``` ##### SE NULL **Descrizione**: `ifnull(field1, field2)` restituisce `field2` se `field1` è nullo. **Tipo di argomento:** + Tutti i tipi di dati supportati. + Se i due parametri hanno tipi diversi, la funzione non supererà il controllo semantico. **Tipo di restituzione:** + Qualsiasi **Esempio**: ``` os> source=accounts | eval result = ifnull(employer, 'default') | fields result, employer, firstname fetched rows / total rows = 4/4 +------------+------------+-------------+ | result | employer | firstname | |------------+------------+-------------| | AnyCompany | AnyCompany | Mary | | ExampleCorp| ExampleCorp| Jane | | ExampleOrg | ExampleOrg | Nikki | | default | null | Juan | +------------+------------+-------------+ ``` ##### NULLIF **Descrizione**: `nullif(field1, field2)` restituisce null se due parametri sono uguali, altrimenti restituisce field1. **Tipo di argomento:** + Tutti i tipi di dati supportati. + Se i due parametri hanno tipi diversi, la funzione non supererà il controllo semantico. **Tipo di restituzione:** + Qualsiasi **Esempio**: ``` os> source=accounts | eval result = nullif(employer, 'AnyCompany') | fields result, employer, firstname fetched rows / total rows = 4/4 +----------------+----------------+-------------+ | result | employer | firstname | |----------------+----------------+-------------| | null | AnyCompany | Mary | | ExampleCorp | ExampleCorp | Jane | | ExampleOrg | ExampleOrg | Nikki | | null | null | Juan | +----------------+----------------+-------------+ ``` ##### IF **Descrizione**: `if(condition, expr1, expr2)` restituisce `expr1` se la condizione è vera, altrimenti restituisce`expr2`. **Tipo di argomento:** + Tutti i tipi di dati supportati. + Se i due parametri hanno tipi diversi, la funzione non supererà il controllo semantico. **Tipo di restituzione:** + Qualsiasi **Esempio**: ``` os> source=accounts | eval result = if(true, firstname, lastname) | fields result, firstname, lastname fetched rows / total rows = 4/4 +----------+-------------+----------+ | result | firstname | lastname | |----------+-------------+----------| | Jane | Jane | Doe | | Mary | Mary | Major | | Pat | Pat | Candella | | Dale | Jorge | Souza | +----------+-----------+------------+ os> source=accounts | eval result = if(false, firstname, lastname) | fields result, firstname, lastname fetched rows / total rows = 4/4 +----------+-------------+------------+ | result | firstname | lastname | |----------+-------------+------------| | Doe | Jane | Doe | | Major | Mary | Major | | Candella | Pat | Candella | | Souza | Jorge | Souza | +----------+-------------+------------+ os> source=accounts | eval is_vip = if(age > 30 AND isnotnull(employer), true, false) | fields is_vip, firstname, lastname fetched rows / total rows = 4/4 +----------+-------------+------------+ | is_vip | firstname | lastname | |----------+-------------+------------| | True | Jane | Doe | | True | Mary | Major | | False | Pat | Candella | | False | Jorge | Souza | +----------+-------------+------------+ ``` ##### funzioni hash crittografiche PPL **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions) ##### MD5 MD5 calcola il MD5 digest e restituisce il valore come stringa esadecimale di 32 caratteri. **Utilizzo:** `md5('hello')` **Tipo di argomento:** + STRING **Tipo di restituzione:** + STRING **Esempio**: ``` os> source=people | eval `MD5('hello')` = MD5('hello') | fields `MD5('hello')` fetched rows / total rows = 1/1 +----------------------------------+ | MD5('hello') | |----------------------------------| | <32 character hex string> | +----------------------------------+ ``` ##### SHA1 SHA1 restituisce il risultato della stringa esadecimale di SHA-1. **Utilizzo:** `sha1('hello')` **Tipo di argomento:** + STRING **Tipo di restituzione:** + STRING **Esempio**: ``` os> source=people | eval `SHA1('hello')` = SHA1('hello') | fields `SHA1('hello')` fetched rows / total rows = 1/1 +------------------------------------------+ | SHA1('hello') | |------------------------------------------| | <40-character SHA-1 hash result> | +------------------------------------------+ ``` ##### SHA2 SHA2 restituisce il risultato della stringa esadecimale della famiglia di funzioni hash SHA-2 (SHA-224, SHA-256, SHA-384 e SHA-512). NumBits indica la lunghezza di bit desiderata del risultato, che deve avere un valore di 224, 256, 384, 512 **Utilizzo:** + `sha2('hello',256)` + `sha2('hello',512)` **Tipo di argomento:** + STRINGA, NUMERO INTERO **Tipo di restituzione:** + STRING **Esempio**: ``` os> source=people | eval `SHA2('hello',256)` = SHA2('hello',256) | fields `SHA2('hello',256)` fetched rows / total rows = 1/1 +------------------------------------------------------------------+ | SHA2('hello',256) | |------------------------------------------------------------------| | <64-character SHA-256 hash result> | +------------------------------------------------------------------+ os> source=people | eval `SHA2('hello',512)` = SHA2('hello',512) | fields `SHA2('hello',512)` fetched rows / total rows = 1/1 +------------------------------------------------------------------+ | SHA2('hello',512) | | |------------------------------------------------------------------| | <128-character SHA-512 hash result> | +------------------------------------------------------------------+ ``` ##### Funzioni di data e ora PPL **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions) ##### `DAY` **Utilizzo**: `DAY(date)` estrae il giorno del mese per una data compresa tra 1 e 31. **Tipo di argomento:** STRING/DATE/TIMESTAMP **Tipo restituito**: INTEGER **Sinonimi**:`DAYOFMONTH`, `DAY_OF_MONTH` **Esempio**: ``` os> source=people | eval `DAY(DATE('2020-08-26'))` = DAY(DATE('2020-08-26')) | fields `DAY(DATE('2020-08-26'))` fetched rows / total rows = 1/1 +---------------------------+ | DAY(DATE('2020-08-26')) | |---------------------------| | 26 | +---------------------------+ ``` ##### `DAYOFMONTH` **Utilizzo**: `DAYOFMONTH(date)` estrae il giorno del mese per una data compresa tra 1 e 31. **Tipo di argomento:** STRING/DATE/TIMESTAMP **Tipo restituito**: INTEGER **Sinonimi**:`DAY`, `DAY_OF_MONTH` **Esempio**: ``` os> source=people | eval `DAYOFMONTH(DATE('2020-08-26'))` = DAYOFMONTH(DATE('2020-08-26')) | fields `DAYOFMONTH(DATE('2020-08-26'))` fetched rows / total rows = 1/1 +----------------------------------+ | DAYOFMONTH(DATE('2020-08-26')) | |----------------------------------| | 26 | +----------------------------------+ ``` ##### `DAY_OF_MONTH` **Utilizzo**: `DAY_OF_MONTH(DATE)` estrae il giorno del mese per una data compresa tra 1 e 31. **Tipo di argomento:** STRING/DATE/TIMESTAMP **Tipo restituito**: INTEGER **Sinonimi**:`DAY`, `DAYOFMONTH` **Esempio**: ``` os> source=people | eval `DAY_OF_MONTH(DATE('2020-08-26'))` = DAY_OF_MONTH(DATE('2020-08-26')) | fields `DAY_OF_MONTH(DATE('2020-08-26'))` fetched rows / total rows = 1/1 +------------------------------------+ | DAY_OF_MONTH(DATE('2020-08-26')) | |------------------------------------| | 26 | +------------------------------------+ ``` ##### `DAYOFWEEK` **Utilizzo**: `DAYOFWEEK(DATE)` restituisce l'indice dei giorni feriali per una data (1 = domenica, 2 = lunedì,..., 7 = sabato). **Tipo di argomento:** STRING/DATE/TIMESTAMP **Tipo restituito**: INTEGER **Sinonimi**: `DAY_OF_WEEK` **Esempio**: ``` os> source=people | eval `DAYOFWEEK(DATE('2020-08-26'))` = DAYOFWEEK(DATE('2020-08-26')) | fields `DAYOFWEEK(DATE('2020-08-26'))` fetched rows / total rows = 1/1 +---------------------------------+ | DAYOFWEEK(DATE('2020-08-26')) | |---------------------------------| | 4 | +---------------------------------+ ``` ##### `DAY_OF_WEEK` **Utilizzo**: `DAY_OF_WEEK(DATE)` restituisce l'indice dei giorni feriali per una data (1 = domenica, 2 = lunedì,..., 7 = sabato). **Tipo di argomento:** STRING/DATE/TIMESTAMP **Tipo restituito**: INTEGER **Sinonimi**: `DAYOFWEEK` **Esempio**: ``` os> source=people | eval `DAY_OF_WEEK(DATE('2020-08-26'))` = DAY_OF_WEEK(DATE('2020-08-26')) | fields `DAY_OF_WEEK(DATE('2020-08-26'))` fetched rows / total rows = 1/1 +-----------------------------------+ | DAY_OF_WEEK(DATE('2020-08-26')) | |-----------------------------------| | 4 | +-----------------------------------+ ``` ##### `DAYOFYEAR` **Utilizzo**: `DAYOFYEAR(DATE)` restituisce il giorno dell'anno per una data compresa tra 1 e 366. **Tipo di argomento:** STRING/DATE/TIMESTAMP **Tipo restituito**: INTEGER **Sinonimi**: `DAY_OF_YEAR` **Esempio**: ``` os> source=people | eval `DAYOFYEAR(DATE('2020-08-26'))` = DAYOFYEAR(DATE('2020-08-26')) | fields `DAYOFYEAR(DATE('2020-08-26'))` fetched rows / total rows = 1/1 +---------------------------------+ | DAYOFYEAR(DATE('2020-08-26')) | |---------------------------------| | 239 | +---------------------------------+ ``` ##### `DAY_OF_YEAR` **Utilizzo**: `DAY_OF_YEAR(DATE)` restituisce il giorno dell'anno per una data compresa tra 1 e 366. **Tipo di argomento:** STRING/DATE/TIMESTAMP **Tipo restituito**: INTEGER **Sinonimi**: `DAYOFYEAR` **Esempio**: ``` os> source=people | eval `DAY_OF_YEAR(DATE('2020-08-26'))` = DAY_OF_YEAR(DATE('2020-08-26')) | fields `DAY_OF_YEAR(DATE('2020-08-26'))` fetched rows / total rows = 1/1 +-----------------------------------+ | DAY_OF_YEAR(DATE('2020-08-26')) | |-----------------------------------| | 239 | +-----------------------------------+ ``` ##### `DAYNAME` **Utilizzo**: `DAYNAME(DATE)` restituisce il nome del giorno della settimana per una data, tra cui lunedì, martedì, mercoledì, giovedì, venerdì, sabato e domenica. **Tipo di argomento:** STRING/DATE/TIMESTAMP **Tipo restituito**: STRING **Esempio**: ``` os> source=people | eval `DAYNAME(DATE('2020-08-26'))` = DAYNAME(DATE('2020-08-26')) | fields `DAYNAME(DATE('2020-08-26'))` fetched rows / total rows = 1/1 +-------------------------------+ | DAYNAME(DATE('2020-08-26')) | |-------------------------------| | Wednesday | +-------------------------------+ ``` ##### `FROM_UNIXTIME` **Utilizzo**: `FROM_UNIXTIME` restituisce una rappresentazione dell'argomento fornito come timestamp o valore di stringa di caratteri. Questa funzione esegue una conversione inversa della `UNIX_TIMESTAMP` funzione. Se fornite un secondo argomento, lo `FROM_UNIXTIME` utilizza per formattare il risultato in modo simile alla `DATE_FORMAT` funzione. Se il timestamp non rientra nell'intervallo dal 1970-01-01 00:00:00 al 3001-01-18 23:59:59.999 999 (da 0 a 32536771199.999999 epoca), la funzione restituisce. `NULL` Tipo **di** argomento: DOUBLE, STRING **Mappa del tipo di ritorno**: DOUBLE -> TIMESTAMP DOUBLE, STRING -> STRING **Esempi:** ``` os> source=people | eval `FROM_UNIXTIME(1220249547)` = FROM_UNIXTIME(1220249547) | fields `FROM_UNIXTIME(1220249547)` fetched rows / total rows = 1/1 +-----------------------------+ | FROM_UNIXTIME(1220249547) | |-----------------------------| | 2008-09-01 06:12:27 | +-----------------------------+ os> source=people | eval `FROM_UNIXTIME(1220249547, 'HH:mm:ss')` = FROM_UNIXTIME(1220249547, 'HH:mm:ss') | fields `FROM_UNIXTIME(1220249547, 'HH:mm:ss')` fetched rows / total rows = 1/1 +-----------------------------------------+ | FROM_UNIXTIME(1220249547, 'HH:mm:ss') | |-----------------------------------------| | 06:12:27 | +-----------------------------------------+ ``` ##### `HOUR` **Utilizzo**: `HOUR(TIME)` estrae il valore dell'ora in base al tempo. A differenza di un'ora del giorno standard, il valore dell'ora in questa funzione può avere un intervallo maggiore di 23. Di conseguenza, il valore restituito da `HOUR(TIME)` può essere maggiore di 23. **Tipo di argomento**: STRING/TIME/TIMESTAMP **Tipo restituito**: INTEGER **Sinonimi**: `HOUR_OF_DAY` **Esempio**: ``` os> source=people | eval `HOUR(TIME('01:02:03'))` = HOUR(TIME('01:02:03')) | fields `HOUR(TIME('01:02:03'))` fetched rows / total rows = 1/1 +--------------------------+ | HOUR(TIME('01:02:03')) | |--------------------------| | 1 | +--------------------------+ ``` ##### `HOUR_OF_DAY` **Utilizzo**: `HOUR_OF_DAY(TIME)` estrae il valore dell'ora dall'ora specificata. A differenza di un'ora del giorno standard, il valore dell'ora in questa funzione può avere un intervallo maggiore di 23. Di conseguenza, il valore restituito da `HOUR_OF_DAY(TIME)` può essere maggiore di 23. **Tipo di argomento**: STRING/TIME/TIMESTAMP **Tipo restituito**: INTEGER **Sinonimi**: `HOUR` **Esempio**: ``` os> source=people | eval `HOUR_OF_DAY(TIME('01:02:03'))` = HOUR_OF_DAY(TIME('01:02:03')) | fields `HOUR_OF_DAY(TIME('01:02:03'))` fetched rows / total rows = 1/1 +---------------------------------+ | HOUR_OF_DAY(TIME('01:02:03')) | |---------------------------------| | 1 | +---------------------------------+ ``` ##### `LAST_DAY` **Utilizzo**: `LAST_DAY` restituisce l'ultimo giorno del mese come valore DATE per l'argomento data specificato. **Tipo di argomento**: DATE/STRING/TIMESTAMP/TIME **Tipo di restituzione**: DATA **Esempio**: ``` os> source=people | eval `last_day('2023-02-06')` = last_day('2023-02-06') | fields `last_day('2023-02-06')` fetched rows / total rows = 1/1 +--------------------------+ | last_day('2023-02-06') | |--------------------------| | 2023-02-28 | +--------------------------+ ``` ##### `LOCALTIMESTAMP` **Utilizzo**: `LOCALTIMESTAMP()` è sinonimo di`NOW()`. **Esempio**: ``` > source=people | eval `LOCALTIMESTAMP()` = LOCALTIMESTAMP() | fields `LOCALTIMESTAMP()` fetched rows / total rows = 1/1 +---------------------+ | LOCALTIMESTAMP() | |---------------------| | 2022-08-02 15:54:19 | +---------------------+ ``` ##### `LOCALTIME` **Utilizzo**: `LOCALTIME()` è sinonimo di`NOW()`. **Esempio**: ``` > source=people | eval `LOCALTIME()` = LOCALTIME() | fields `LOCALTIME()` fetched rows / total rows = 1/1 +---------------------+ | LOCALTIME() | |---------------------| | 2022-08-02 15:54:19 | +---------------------+ ``` ##### `MAKE_DATE` **Utilizzo**: `MAKE_DATE` restituisce un valore di data basato sui valori di anno, mese e giorno specificati. Tutti gli argomenti sono arrotondati a numeri interi. **Specifiche**: 1. MAKE\$1DATE (INTERO, INTERO, INTERO) -> DATA **Tipo di argomento**: INTEGER, INTEGER, INTEGER **Tipo di restituzione**: DATE **Esempio**: ``` os> source=people | eval `MAKE_DATE(1945, 5, 9)` = MAKEDATE(1945, 5, 9) | fields `MAKEDATE(1945, 5, 9)` fetched rows / total rows = 1/1 +------------------------+ | MAKEDATE(1945, 5, 9) | |------------------------| | 1945-05-09 | +------------------------+ ``` ##### `MINUTE` **Utilizzo**: `MINUTE(TIME)` restituisce la componente in minuti dell'ora specificata, come numero intero compreso tra 0 e 59. **Tipo di argomento:** STRING/TIME/TIMESTAMP **Tipo restituito**: INTEGER **Sinonimi**: `MINUTE_OF_HOUR` **Esempio**: ``` os> source=people | eval `MINUTE(TIME('01:02:03'))` = MINUTE(TIME('01:02:03')) | fields `MINUTE(TIME('01:02:03'))` fetched rows / total rows = 1/1 +----------------------------+ | MINUTE(TIME('01:02:03')) | |----------------------------| | 2 | +----------------------------+ ``` ##### `MINUTE_OF_HOUR` **Utilizzo**: `MINUTE_OF_HOUR(TIME)` restituisce il componente minuto del tempo specificato, come numero intero compreso tra 0 e 59. **Tipo di argomento:** STRING/TIME/TIMESTAMP **Tipo restituito**: INTEGER **Sinonimi**: `MINUTE` **Esempio**: ``` os> source=people | eval `MINUTE_OF_HOUR(TIME('01:02:03'))` = MINUTE_OF_HOUR(TIME('01:02:03')) | fields `MINUTE_OF_HOUR(TIME('01:02:03'))` fetched rows / total rows = 1/1 +------------------------------------+ | MINUTE_OF_HOUR(TIME('01:02:03')) | |------------------------------------| | 2 | +------------------------------------+ ``` ##### `MONTH` **Utilizzo**: `MONTH(DATE)` restituisce il mese della data specificata come numero intero, nell'intervallo da 1 a 12 (dove 1 rappresenta gennaio e 12 rappresenta dicembre). **Tipo di argomento:** STRING/DATE/TIMESTAMP **Tipo restituito**: INTEGER **Sinonimi**: `MONTH_OF_YEAR` **Esempio**: ``` os> source=people | eval `MONTH(DATE('2020-08-26'))` = MONTH(DATE('2020-08-26')) | fields `MONTH(DATE('2020-08-26'))` fetched rows / total rows = 1/1 +-----------------------------+ | MONTH(DATE('2020-08-26')) | |-----------------------------| | 8 | +-----------------------------+ ``` ##### `MONTHNAME` **Utilizzo**: `MONTHNAME(DATE)` restituisce il mese della data specificata come numero intero, nell'intervallo da 1 a 12 (dove 1 rappresenta gennaio e 12 rappresenta dicembre). **Tipo di argomento:** STRING/DATE/TIMESTAMP **Tipo restituito**: INTEGER **Sinonimi**: `MONTH_OF_YEAR` **Esempio**: ``` os> source=people | eval `MONTHNAME(DATE('2020-08-26'))` = MONTHNAME(DATE('2020-08-26')) | fields `MONTHNAME(DATE('2020-08-26'))` fetched rows / total rows = 1/1 +---------------------------------+ | MONTHNAME(DATE('2020-08-26')) | |---------------------------------| | August | +---------------------------------+ ``` ##### `MONTH_OF_YEAR` **Utilizzo**: `MONTH_OF_YEAR(DATE)` restituisce il mese della data specificata come numero intero, nell'intervallo da 1 a 12 (dove 1 rappresenta gennaio e 12 rappresenta dicembre). **Tipo di argomento:** STRING/DATE/TIMESTAMP **Tipo restituito**: INTEGER **Sinonimi**: `MONTH` **Esempio**: ``` os> source=people | eval `MONTH_OF_YEAR(DATE('2020-08-26'))` = MONTH_OF_YEAR(DATE('2020-08-26')) | fields `MONTH_OF_YEAR(DATE('2020-08-26'))` fetched rows / total rows = 1/1 +-------------------------------------+ | MONTH_OF_YEAR(DATE('2020-08-26')) | |-------------------------------------| | 8 | +-------------------------------------+ ``` ##### `NOW` **Utilizzo**: `NOW` restituisce la data e l'ora correnti come `TIMESTAMP` valore nel formato YYYY-MM-DD 'hh:mm:ss'. Il valore è espresso nel fuso orario del cluster. **Nota** `NOW()`restituisce un tempo costante che indica quando l'istruzione ha iniziato l'esecuzione. Questo differisce da`SYSDATE()`, che restituisce l'ora esatta di esecuzione. **Tipo di restituzione: TIMESTAMP** **Specificazione**: NOW () -> TIMESTAMP **Esempio**: ``` os> source=people | eval `value_1` = NOW(), `value_2` = NOW() | fields `value_1`, `value_2` fetched rows / total rows = 1/1 +---------------------+---------------------+ | value_1 | value_2 | |---------------------+---------------------| | 2022-08-02 15:39:05 | 2022-08-02 15:39:05 | +---------------------+---------------------+ ``` ##### `QUARTER` **Utilizzo**: `QUARTER(DATE)` restituisce il trimestre dell'anno per la data specificata come numero intero, nell'intervallo da 1 a 4. **Tipo di argomento:** STRING/DATE/TIMESTAMP **Tipo restituito**: INTEGER **Esempio**: ``` os> source=people | eval `QUARTER(DATE('2020-08-26'))` = QUARTER(DATE('2020-08-26')) | fields `QUARTER(DATE('2020-08-26'))` fetched rows / total rows = 1/1 +-------------------------------+ | QUARTER(DATE('2020-08-26')) | |-------------------------------| | 3 | +-------------------------------+ ``` ##### `SECOND` **Utilizzo**: `SECOND(TIME)` restituisce il secondo componente dell'ora specificata come numero intero, nell'intervallo da 0 a 59. **Tipo di argomento:** STRING/TIME/TIMESTAMP **Tipo restituito**: INTEGER **Sinonimi**: `SECOND_OF_MINUTE` **Esempio**: ``` os> source=people | eval `SECOND(TIME('01:02:03'))` = SECOND(TIME('01:02:03')) | fields `SECOND(TIME('01:02:03'))` fetched rows / total rows = 1/1 +----------------------------+ | SECOND(TIME('01:02:03')) | |----------------------------| | 3 | +----------------------------+ ``` ##### `SECOND_OF_MINUTE` **Utilizzo**: `SECOND_OF_MINUTE(TIME)` restituisce il secondo componente del tempo specificato come numero intero, nell'intervallo da 0 a 59. **Tipo di argomento:** STRING/TIME/TIMESTAMP **Tipo restituito**: INTEGER **Sinonimi**: `SECOND` **Esempio**: ``` os> source=people | eval `SECOND_OF_MINUTE(TIME('01:02:03'))` = SECOND_OF_MINUTE(TIME('01:02:03')) | fields `SECOND_OF_MINUTE(TIME('01:02:03'))` fetched rows / total rows = 1/1 +--------------------------------------+ | SECOND_OF_MINUTE(TIME('01:02:03')) | |--------------------------------------| | 3 | +--------------------------------------+ ``` ##### `SUBDATE` **Utilizzo**: `SUBDATE(DATE, DAYS)` sottrae il secondo argomento (ad esempio `DATE` o`DAYS`) dalla data specificata. **Tipo di argomento: DATE/TIMESTAMP**, LONG **Mappa del tipo di ritorno**: (DATE, LONG) -> DATE **Contrari**: `ADDDATE` **Esempio**: ``` os> source=people | eval `'2008-01-02' - 31d` = SUBDATE(DATE('2008-01-02'), 31), `'2020-08-26' - 1` = SUBDATE(DATE('2020-08-26'), 1), `ts '2020-08-26 01:01:01' - 1` = SUBDATE(TIMESTAMP('2020-08-26 01:01:01'), 1) | fields `'2008-01-02' - 31d`, `'2020-08-26' - 1`, `ts '2020-08-26 01:01:01' - 1` fetched rows / total rows = 1/1 +----------------------+--------------------+--------------------------------+ | '2008-01-02' - 31d | '2020-08-26' - 1 | ts '2020-08-26 01:01:01' - 1 | |----------------------+--------------------+--------------------------------| | 2007-12-02 00:00:00 | 2020-08-25 | 2020-08-25 01:01:01 | +----------------------+--------------------+--------------------------------+ ``` ##### `SYSDATE` **Utilizzo**: `SYSDATE()` restituisce la data e l'ora correnti come `TIMESTAMP` valore nel formato 'YYYY-MM-DD hh:mm:ss.nnnnnnn'. `SYSDATE()`restituisce l'ora esatta in cui viene eseguito. Ciò differisce da NOW (), che restituisce un tempo costante che indica quando l'istruzione ha iniziato l'esecuzione. **Tipo di argomento opzionale**: INTEGER (da 0 a 6): specifica il numero di cifre per frazioni di secondo nel valore restituito. **Tipo restituito: TIMESTAMP** **Esempio**: ``` os> source=people | eval `SYSDATE()` = SYSDATE() | fields `SYSDATE()` fetched rows / total rows = 1/1 +----------------------------+ | SYSDATE() | |----------------------------| | 2022-08-02 15:39:05.123456 | +----------------------------+ ``` ##### `TIMESTAMP` **Utilizzo**: `TIMESTAMP(EXPR)` costruisce un tipo di timestamp con la stringa di input come timestamp. `expr` Con un solo argomento, `TIMESTAMP(expr)` costruisce un timestamp dall'input. Se `expr` è una stringa, viene interpretata come un timestamp. Per argomenti non di tipo stringa, la funzione esegue il cast su un timestamp `expr` utilizzando il fuso orario UTC. Quando `expr` è un `TIME` valore, la funzione applica la data odierna prima del casting. Se utilizzata con due argomenti, `TIMESTAMP(expr1, expr2)` aggiunge l'espressione time (`expr2`) all'espressione date o timestamp (`expr1`) e restituisce il risultato come valore di timestamp. **Tipo di argomento:** STRING/DATE/TIME/TIMESTAMP **Mappa del tipo di ritorno**: (STRING/DATE/TIME/TIMESTAMP) -> TIMESTAMP () -> STRING/DATE/TIME/TIMESTAMP, STRING/DATE/TIME/TIMESTAMP TIMESTAMP **Esempio**: ``` os> source=people | eval `TIMESTAMP('2020-08-26 13:49:00')` = TIMESTAMP('2020-08-26 13:49:00'), `TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42'))` = TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42')) | fields `TIMESTAMP('2020-08-26 13:49:00')`, `TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42'))` fetched rows / total rows = 1/1 +------------------------------------+------------------------------------------------------+ | TIMESTAMP('2020-08-26 13:49:00') | TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42')) | |------------------------------------+------------------------------------------------------| | 2020-08-26 13:49:00 | 2020-08-27 02:04:42 | +------------------------------------+------------------------------------------------------+ ``` ##### `UNIX_TIMESTAMP` **Utilizzo**: `UNIX_TIMESTAMP` converte un determinato argomento di data in ora Unix (secondi dall'Epoca, iniziata all'inizio del 1970). Se non viene fornito alcun argomento, restituisce l'ora Unix corrente. L'argomento della data può essere un`DATE`, una `TIMESTAMP` stringa o un numero in uno dei seguenti formati:`YYMMDD`, `YYMMDDhhmmss``YYYYMMDD`, o`YYYYMMDDhhmmss`. Se l'argomento include un componente temporale, può facoltativamente includere frazioni di secondi. Se l'argomento è in un formato non valido o non rientra nell'intervallo compreso tra 00:00:00 e 3001-01-18 23:59:59.999 (da 0 a 32536771199.999999 nell'ora dell'epoca), la funzione restituisce. `NULL` La `DOUBLE` funzione accetta o come tipi di argomento `DATE` o nessun argomento. `TIMESTAMP` Restituisce sempre un `DOUBLE` valore che rappresenta il timestamp Unix. Per la conversione inversa, puoi usare la funzione FROM\$1UNIXTIME. **Tipo di argomento:/DOUBLE/DATE/TIMESTAMP** **Tipo di restituzione**: DOUBLE **Esempio**: ``` os> source=people | eval `UNIX_TIMESTAMP(double)` = UNIX_TIMESTAMP(20771122143845), `UNIX_TIMESTAMP(timestamp)` = UNIX_TIMESTAMP(TIMESTAMP('1996-11-15 17:05:42')) | fields `UNIX_TIMESTAMP(double)`, `UNIX_TIMESTAMP(timestamp)` fetched rows / total rows = 1/1 +--------------------------+-----------------------------+ | UNIX_TIMESTAMP(double) | UNIX_TIMESTAMP(timestamp) | |--------------------------+-----------------------------| | 3404817525.0 | 848077542.0 | +--------------------------+-----------------------------+ ``` ##### `WEEK` **Utilizzo**: `WEEK(DATE)` restituisce il numero della settimana per una determinata data. **Tipo di argomento**: DATE/TIMESTAMP/STRING **Tipo restituito**: INTEGER **Sinonimi**: `WEEK_OF_YEAR` **Esempio**: ``` os> source=people | eval `WEEK(DATE('2008-02-20'))` = WEEK(DATE('2008-02-20')) | fields `WEEK(DATE('2008-02-20'))` fetched rows / total rows = 1/1 +----------------------------+ | WEEK(DATE('2008-02-20')) | |----------------------------| | 8 | +----------------------------+ ``` ##### `WEEKDAY` **Utilizzo**: `WEEKDAY(DATE)` restituisce l'indice dei giorni feriali per la data (0 = lunedì, 1 = martedì,..., 6 = domenica). È simile alla `dayofweek` funzione, ma restituisce indici diversi per ogni giorno. Tipo di **argomento**: STRING/DATE/TIME/TIMESTAMP **Tipo restituito**: INTEGER **Esempio**: ``` os> source=people | eval `weekday(DATE('2020-08-26'))` = weekday(DATE('2020-08-26')) | eval `weekday(DATE('2020-08-27'))` = weekday(DATE('2020-08-27')) | fields `weekday(DATE('2020-08-26'))`, `weekday(DATE('2020-08-27'))` fetched rows / total rows = 1/1 +-------------------------------+-------------------------------+ | weekday(DATE('2020-08-26')) | weekday(DATE('2020-08-27')) | |-------------------------------+-------------------------------| | 2 | 3 | +-------------------------------+-------------------------------+ ``` ##### `WEEK_OF_YEAR` **Utilizzo**: `WEEK_OF_YEAR(DATE)` restituisce il numero della settimana per la data specificata. **Tipo di argomento**: DATE/TIMESTAMP/STRING **Tipo restituito**: INTEGER **Sinonimi**: `WEEK` **Esempio**: ``` os> source=people | eval `WEEK_OF_YEAR(DATE('2008-02-20'))` = WEEK(DATE('2008-02-20'))| fields `WEEK_OF_YEAR(DATE('2008-02-20'))` fetched rows / total rows = 1/1 +------------------------------------+ | WEEK_OF_YEAR(DATE('2008-02-20')) | |------------------------------------| | 8 | +------------------------------------+ ``` ##### `YEAR` **Utilizzo**: `YEAR(DATE)` restituisce l'anno come data, nell'intervallo da 1000 a 9999 o 0 per la data «zero». **Tipo di argomento**: STRING/DATE/TIMESTAMP **Tipo restituito**: INTEGER **Esempio**: ``` os> source=people | eval `YEAR(DATE('2020-08-26'))` = YEAR(DATE('2020-08-26')) | fields `YEAR(DATE('2020-08-26'))` fetched rows / total rows = 1/1 +----------------------------+ | YEAR(DATE('2020-08-26')) | |----------------------------| | 2020 | +----------------------------+ ``` ##### `DATE_ADD` **Utilizzo**: `DATE_ADD(date, INTERVAL expr unit)` aggiunge l'intervallo specificato alla data specificata. **Tipo di argomento**: DATE, INTERVAL **Tipo di restituzione**: DATE **Contrari**: `DATE_SUB` **Esempio**: ``` os> source=people | eval `'2020-08-26' + 1d` = DATE_ADD(DATE('2020-08-26'), INTERVAL 1 DAY) | fields `'2020-08-26' + 1d` fetched rows / total rows = 1/1 +---------------------+ | '2020-08-26' + 1d | |---------------------| | 2020-08-27 | +---------------------+ ``` ##### `DATE_SUB` **Utilizzo**: `DATE_SUB(date, INTERVAL expr unit)` sottrae l'intervallo expr dalla data. **Tipo di argomento**: DATE, INTERVAL **Tipo di restituzione**: DATE **Contrari**: `DATE_ADD` **Esempio**: ``` os> source=people | eval `'2008-01-02' - 31d` = DATE_SUB(DATE('2008-01-02'), INTERVAL 31 DAY) | fields `'2008-01-02' - 31d` fetched rows / total rows = 1/1 +---------------------+ | '2008-01-02' - 31d | |---------------------| | 2007-12-02 | +---------------------+ ``` ##### `TIMESTAMPADD` **Utilizzo**: restituisce un `TIMESTAMP` valore dopo aver aggiunto un intervallo di tempo specificato a una determinata data. **Argomenti**: + INTERVALLO: INTERVALLO (SECONDO, MINUTO, ORA, GIORNO, SETTIMANA, MESE, TRIMESTRE, ANNO) + numero intero: INTERO + data: DATE, TIMESTAMP o STRING Se fornisci un `STRING` come argomento per la data, formattalo come valido. `TIMESTAMP` La funzione converte automaticamente un `DATE` argomento in un`TIMESTAMP`. **Esempi:** ``` os> source=people | eval `TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00')` = TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00') | eval `TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00')` = TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00') | fields `TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00')`, `TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00')` fetched rows / total rows = 1/1 +----------------------------------------------+--------------------------------------------------+ | TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00') | TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00') | |----------------------------------------------+--------------------------------------------------| | 2000-01-18 00:00:00 | 1999-10-01 00:00:00 | +----------------------------------------------+--------------------------------------------------+ ``` ##### `TIMESTAMPDIFF` **Utilizzo**: `TIMESTAMPDIFF(interval, start, end)` restituisce la differenza tra l'inizio e la fine date/times in unità di intervallo specificate. **Argomenti**: + INTERVALLO: INTERVALLO (SECONDO, MINUTO, ORA, GIORNO, SETTIMANA, MESE, TRIMESTRE, ANNO) + inizio: DATE, TIMESTAMP o STRING + fine: DATE, TIMESTAMP o STRING La funzione converte automaticamente gli argomenti in modo appropriato. `TIMESTAMP` Formatta `STRING` gli argomenti come file validi`TIMESTAMP`. **Esempi:** ``` os> source=people | eval `TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00')` = TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00') | eval `TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00'))` = TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00')) | fields `TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00')`, `TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00'))` fetched rows / total rows = 1/1 +-------------------------------------------------------------------+-------------------------------------------------------------------------------------------+ | TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00') | TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00')) | |-------------------------------------------------------------------+-------------------------------------------------------------------------------------------| | 4 | -23 | +-------------------------------------------------------------------+-------------------------------------------------------------------------------------------+ ``` ##### `UTC_TIMESTAMP` **Utilizzo**: `UTC_TIMESTAMP` restituisce il timestamp UTC corrente come valore in 'YYYY-MM-DD hh:mm:ss'. **Tipo** di restituzione: TIMESTAMP **Specificazione**: UTC\$1TIMESTAMP () -> TIMESTAMP **Esempio**: ``` > source=people | eval `UTC_TIMESTAMP()` = UTC_TIMESTAMP() | fields `UTC_TIMESTAMP()` fetched rows / total rows = 1/1 +---------------------+ | UTC_TIMESTAMP() | |---------------------| | 2022-10-03 17:54:28 | +---------------------+ ``` ##### `CURRENT_TIMEZONE` **Utilizzo: restituisce** il fuso orario locale corrente. `CURRENT_TIMEZONE` **Tipo restituito: STRING** **Esempio**: ``` > source=people | eval `CURRENT_TIMEZONE()` = CURRENT_TIMEZONE() | fields `CURRENT_TIMEZONE()` fetched rows / total rows = 1/1 +------------------------+ | CURRENT_TIMEZONE() | |------------------------| | America/Chicago | +------------------------+ ``` ##### espressioni PPL **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions) Le espressioni, in particolare le espressioni di valore, restituiscono un valore scalare. Le espressioni hanno tipi e forme diversi. Ad esempio, esistono valori letterali come espressioni atomiche ed espressioni aritmetiche, predicative e funzionali basate su di essi. È possibile utilizzare le espressioni in diverse clausole, ad esempio l'utilizzo di espressioni aritmetiche nei comandi and. `Filter` `Stats` **Operatori** Un'espressione aritmetica è un'espressione formata da valori letterali numerici e operatori aritmetici binari come segue: 1. `+`: Aggiungi. 1. `-`: Sottrai. 1. `*`: Moltiplica. 1. `/`: Dividi (per i numeri interi, il risultato è un numero intero con la parte frazionaria scartata) 1. `%`: Modulo (da utilizzare solo con numeri interi; il risultato è il resto della divisione) **Precedenza** Utilizzate le parentesi per controllare la precedenza degli operatori aritmetici. Altrimenti, gli operatori con precedenza più alta vengono eseguiti per primi. **Conversione del tipo** La conversione implicita dei tipi viene eseguita durante la ricerca delle firme degli operatori. Ad esempio, un numero intero corrisponde `+` a una firma `+(double,double)` che dà come risultato un numero reale. Questa regola si applica anche alle chiamate di funzione. Esempio per diversi tipi di espressioni aritmetiche: ``` os> source=accounts | where age > (25 + 5) | fields age ; fetched rows / total rows = 3/3 +-------+ | age | |-------| | 32 | | 36 | | 33 | +-------+ ``` **Operatori predicati** Un operatore predicato è un'espressione che risulta vera. Il confronto dei `NULL` valori `MISSING` e segue queste regole: + Un `MISSING` valore è solo uguale a un `MISSING` valore ed è inferiore agli altri valori. + Un `NULL` valore è uguale a un `NULL` valore, è maggiore di un `MISSING` valore, ma è minore di tutti gli altri valori. **Operatori** **Operatori predicati** | Nome | Description | | --- | --- | | > | Maggiore dell'operatore | | >= | Operatore maggiore o uguale | | < | Meno dell'operatore | | \$1= | Operatore non uguale | | <= | Operatore minore o uguale | | = | Operatore uguale | | LIKE | Corrispondenza semplice dei modelli | | IN | Test del valore NULL | | AND | Operatore AND | | OR | Operatore OR | | XOR | Operatore XOR | | NOT | Test del valore NOT NULL | Puoi confrontare le date e le ore. Quando si confrontano diversi tipi di datetime (ad esempio `DATE` e`TIME`), entrambi vengono convertiti in. `DATETIME` Le seguenti regole si applicano alla conversione: + `TIME`si applica alla data odierna. + `DATE`viene interpretato a mezzanotte. **Operatore di predicato di base** Esempio di operatori di confronto: ``` os> source=accounts | where age > 33 | fields age ; fetched rows / total rows = 1/1 +-------+ | age | |-------| | 36 | +-------+ ``` **`IN`** Esempio del campo di test `IN` dell'operatore nelle liste di valori: ``` os> source=accounts | where age in (32, 33) | fields age ; fetched rows / total rows = 2/2 +-------+ | age | |-------| | 32 | | 33 | +-------+ ``` **`OR`** Esempio dell'`OR`operatore: ``` os> source=accounts | where age = 32 OR age = 33 | fields age ; fetched rows / total rows = 2/2 +-------+ | age | |-------| | 32 | | 33 | +-------+ ``` **`NOT`** Esempio dell'`NOT`operatore: ``` os> source=accounts | where age not in (32, 33) | fields age ; fetched rows / total rows = 2/2 +-------+ | age | |-------| | 36 | | 28 | +-------+ ``` ##### Funzioni degli indirizzi IP PPL **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions) ##### `CIDRMATCH` **Utilizzo**: `CIDRMATCH(ip, cidr)` verifica se l'indirizzo IP specificato rientra nell'intervallo cidr specificato. **Tipo di argomento:** + STRINGA, STRINGA + Tipo restituito: BOOLEAN **Esempio**: ``` os> source=ips | where cidrmatch(ip, '***********/24') | fields ip fetched rows / total rows = 1/1 +--------------+ | ip | |--------------| | *********** | +--------------+ os> source=ipsv6 | where cidrmatch(ip, '2003:db8::/32') | fields ip fetched rows / total rows = 1/1 +-----------------------------------------+ | ip | |-----------------------------------------| | 2003:0db8:****:****:****:****:****:0000 | +-----------------------------------------+ ``` **Nota** `ip`può essere un indirizzo IPv4 o. IPv6 `cidr`può essere un IPv4 o un IPv6 blocco. `ip`e `cidr` deve essere entrambi IPv4 o entrambi IPv6. `ip`e `cidr` devono essere entrambi validi e non vuoti/non nulli. ##### Funzioni PPL JSON **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions) ##### `JSON` **Utilizzo**: `json(value)` valuta se una stringa può essere analizzata come formato JSON. La funzione restituisce la stringa originale se è JSON valido o null se non è valida. Tipo di **argomento**: STRING **Tipo restituito**: STRING/NULL. Un'espressione STRING di un formato di oggetto JSON valido. **Esempi:** ``` os> source=people | eval `valid_json()` = json('[1,2,3,{"f1":1,"f2":[5,6]},4]') | fields valid_json fetched rows / total rows = 1/1 +---------------------------------+ | valid_json | +---------------------------------+ | [1,2,3,{"f1":1,"f2":[5,6]},4] | +---------------------------------+ os> source=people | eval `invalid_json()` = json('{"invalid": "json"') | fields invalid_json fetched rows / total rows = 1/1 +----------------+ | invalid_json | +----------------+ | null | +----------------+ ``` ##### `JSON_OBJECT` **Utilizzo**: `json_object(, [, , ]...)` restituisce un oggetto JSON dai membri di coppie chiave-valore. **Tipo di argomento:** + A deve essere STRING. + A può essere qualsiasi tipo di dati. **Tipo restituito**: JSON\$1OBJECT. Un' StructType espressione di un oggetto JSON valido. **Esempi:** ``` os> source=people | eval result = json_object('key', 123.45) | fields result fetched rows / total rows = 1/1 +------------------+ | result | +------------------+ | {"key":123.45} | +------------------+ os> source=people | eval result = json_object('outer', json_object('inner', 123.45)) | fields result fetched rows / total rows = 1/1 +------------------------------+ | result | +------------------------------+ | {"outer":{"inner":123.45}} | +------------------------------+ ``` ##### `JSON_ARRAY` **Utilizzo**: `json_array(...)` crea un JSON ARRAY utilizzando un elenco di valori. **Tipo di argomento**: A `` può essere qualsiasi tipo di valore come stringa, numero o booleano. **Tipo restituito: ARRAY**. Un array di qualsiasi tipo di dati supportato per un array JSON valido. **Esempi:** ``` os> source=people | eval `json_array` = json_array(1, 2, 0, -1, 1.1, -0.11) fetched rows / total rows = 1/1 +------------------------------+ | json_array | +------------------------------+ | [1.0,2.0,0.0,-1.0,1.1,-0.11] | +------------------------------+ os> source=people | eval `json_array_object` = json_object("array", json_array(1, 2, 0, -1, 1.1, -0.11)) fetched rows / total rows = 1/1 +----------------------------------------+ | json_array_object | +----------------------------------------+ | {"array":[1.0,2.0,0.0,-1.0,1.1,-0.11]} | +----------------------------------------+ ``` ##### `TO_JSON_STRING` **Utilizzo**: `to_json_string(jsonObject)` restituisce una stringa JSON con un determinato valore di oggetto json. **Tipo di argomento**: JSON\$1OBJECT **Tipo restituito**: STRING **Esempi:** ``` os> source=people | eval `json_string` = to_json_string(json_array(1, 2, 0, -1, 1.1, -0.11)) | fields json_string fetched rows / total rows = 1/1 +--------------------------------+ | json_string | +--------------------------------+ | [1.0,2.0,0.0,-1.0,1.1,-0.11] | +--------------------------------+ os> source=people | eval `json_string` = to_json_string(json_object('key', 123.45)) | fields json_string fetched rows / total rows = 1/1 +-----------------+ | json_string | +-----------------+ | {'key', 123.45} | +-----------------+ ``` ##### `ARRAY_LENGTH` **Utilizzo**: `array_length(jsonArray)` restituisce il numero di elementi nell'array più esterno. **Tipo di argomento: ARRAY**. Un oggetto ARRAY o JSON\$1ARRAY. **Tipo restituito**: INTEGER **Esempio**: ``` os> source=people | eval `json_array` = json_array_length(json_array(1,2,3,4)), `empty_array` = json_array_length(json_array()) fetched rows / total rows = 1/1 +--------------+---------------+ | json_array | empty_array | +--------------+---------------+ | 4 | 0 | +--------------+---------------+ ``` ##### `JSON_EXTRACT` **Utilizzo**: `json_extract(jsonStr, path)` estrae un oggetto JSON da una stringa JSON in base al percorso JSON specificato. La funzione restituisce null se la stringa JSON di input non è valida. **Tipo di argomento: STRING**, STRING **Tipo restituito**: STRING + Un'espressione STRING di un formato di oggetto JSON valido. + `NULL`viene restituito in caso di JSON non valido. **Esempi:** ``` os> source=people | eval `json_extract('{"a":"b"}', '$.a')` = json_extract('{"a":"b"}', '$a') fetched rows / total rows = 1/1 +----------------------------------+ | json_extract('{"a":"b"}', 'a') | +----------------------------------+ | b | +----------------------------------+ os> source=people | eval `json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[1].b')` = json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[1].b') fetched rows / total rows = 1/1 +-----------------------------------------------------------+ | json_extract('{"a":[{"b":1.0},{"b":2.0}]}', '$.a[1].b') | +-----------------------------------------------------------+ | 2.0 | +-----------------------------------------------------------+ os> source=people | eval `json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[*].b')` = json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[*].b') fetched rows / total rows = 1/1 +-----------------------------------------------------------+ | json_extract('{"a":[{"b":1.0},{"b":2.0}]}', '$.a[*].b') | +-----------------------------------------------------------+ | [1.0,2.0] | +-----------------------------------------------------------+ os> source=people | eval `invalid_json` = json_extract('{"invalid": "json"') fetched rows / total rows = 1/1 +----------------+ | invalid_json | +----------------+ | null | +----------------+ ``` ##### `JSON_KEYS` **Utilizzo**: `json_keys(jsonStr)` restituisce tutte le chiavi dell'oggetto JSON più esterno come array. **Tipo di argomento**: STRING. Un'espressione STRING di un formato di oggetto JSON valido. **Tipo restituito**: ARRAY [STRING]. La funzione restituisce `NULL` qualsiasi altra stringa JSON valida, una stringa vuota o un codice JSON non valido. **Esempi:** ``` os> source=people | eval `keys` = json_keys('{"f1":"abc","f2":{"f3":"a","f4":"b"}}') fetched rows / total rows = 1/1 +------------+ | keus | +------------+ | [f1, f2] | +------------+ os> source=people | eval `keys` = json_keys('[1,2,3,{"f1":1,"f2":[5,6]},4]') fetched rows / total rows = 1/1 +--------+ | keys | +--------+ | null | +--------+ ``` ##### `JSON_VALID` **Utilizzo**: `json_valid(jsonStr)` valuta se una stringa JSON utilizza una sintassi JSON valida e restituisce TRUE o FALSE. **Tipo di argomento: STRING** **Tipo restituito**: BOOLEAN **Esempi:** ``` os> source=people | eval `valid_json` = json_valid('[1,2,3,4]'), `invalid_json` = json_valid('{"invalid": "json"') | feilds `valid_json`, `invalid_json` fetched rows / total rows = 1/1 +--------------+----------------+ | valid_json | invalid_json | +--------------+----------------+ | True | False | +--------------+----------------+ os> source=accounts | where json_valid('[1,2,3,4]') and isnull(email) | fields account_number, email fetched rows / total rows = 1/1 +------------------+---------+ | account_number | email | |------------------+---------| | 13 | null | +------------------+---------+ ``` ##### Funzioni PPL Lambda **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions) ##### `EXISTS` **Utilizzo**: `exists(array, lambda)` valuta se un predicato Lambda è valido per uno o più elementi dell'array. **Tipo di argomento**: ARRAY, LAMBDA **Tipo restituito**: BOOLEAN. Restituisce `TRUE` se almeno un elemento dell'array soddisfa il predicato Lambda, altrimenti. `FALSE` **Esempi:** ``` os> source=people | eval array = json_array(1, -1, 2), result = exists(array, x -> x > 0) | fields result fetched rows / total rows = 1/1 +-----------+ | result | +-----------+ | true | +-----------+ os> source=people | eval array = json_array(-1, -3, -2), result = exists(array, x -> x > 0) | fields result fetched rows / total rows = 1/1 +-----------+ | result | +-----------+ | false | +-----------+ ``` ##### `FILTER` **Utilizzo**: `filter(array, lambda)` filtra l'array di input utilizzando la funzione Lambda specificata. **Tipo di argomento**: ARRAY, LAMBDA **Tipo restituito**: ARRAY. Un ARRAY che contiene tutti gli elementi dell'array di input che soddisfano il predicato lambda. **Esempi:** ``` os> source=people | eval array = json_array(1, -1, 2), result = filter(array, x -> x > 0) | fields result fetched rows / total rows = 1/1 +-----------+ | result | +-----------+ | [1, 2] | +-----------+ os> source=people | eval array = json_array(-1, -3, -2), result = filter(array, x -> x > 0) | fields result fetched rows / total rows = 1/1 +-----------+ | result | +-----------+ | [] | +-----------+ ``` ##### `TRANSFORM` **Utilizzo**: `transform(array, lambda)` trasforma gli elementi di un array utilizzando la funzione di trasformazione Lambda. Il secondo argomento implica l'indice dell'elemento se si utilizza la funzione binaria Lambda. È simile a una `map` nella programmazione funzionale. **Tipo di argomento**: ARRAY, LAMBDA **Tipo restituito**: ARRAY. Un ARRAY che contiene il risultato dell'applicazione della funzione di trasformazione lambda a ciascun elemento dell'array di input. **Esempi:** ``` os> source=people | eval array = json_array(1, 2, 3), result = transform(array, x -> x + 1) | fields result fetched rows / total rows = 1/1 +--------------+ | result | +--------------+ | [2, 3, 4] | +--------------+ os> source=people | eval array = json_array(1, 2, 3), result = transform(array, (x, i) -> x + i) | fields result fetched rows / total rows = 1/1 +--------------+ | result | +--------------+ | [1, 3, 5] | +--------------+ ``` ##### `REDUCE` **Utilizzo**: `reduce(array, start, merge_lambda, finish_lambda)` riduce un array a un singolo valore applicando le funzioni lambda. La funzione applica merge\$1lambda al valore iniziale e a tutti gli elementi dell'array, quindi applica il valore al risultato. `finish_lambda` **Tipo di argomento**: ARRAY, ANY, LAMBDA, LAMBDA **Tipo di restituzione**: ANY. Il risultato finale dell'applicazione delle funzioni Lambda al valore iniziale e all'array di input. **Esempi:** ``` os> source=people | eval array = json_array(1, 2, 3), result = reduce(array, 0, (acc, x) -> acc + x) | fields result fetched rows / total rows = 1/1 +-----------+ | result | +-----------+ | 6 | +-----------+ os> source=people | eval array = json_array(1, 2, 3), result = reduce(array, 10, (acc, x) -> acc + x) | fields result fetched rows / total rows = 1/1 +-----------+ | result | +-----------+ | 16 | +-----------+ os> source=people | eval array = json_array(1, 2, 3), result = reduce(array, 0, (acc, x) -> acc + x, acc -> acc * 10) | fields result fetched rows / total rows = 1/1 +-----------+ | result | +-----------+ | 60 | +-----------+ ``` ##### Funzioni matematiche PPL **Nota** Per vedere quali integrazioni di sorgenti AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions) ##### `ABS` **Utilizzo**: `ABS(x) ` calcola il valore assoluto di x. **Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione:** INTEGER/LONG/FLOAT/DOUBLE **Esempio**: ``` os> source=people | eval `ABS(-1)` = ABS(-1) | fields `ABS(-1)` fetched rows / total rows = 1/1 +-----------+ | ABS(-1) | |-----------| | 1 | +-----------+ ``` ##### `ACOS` **Utilizzo**: `ACOS(x)` calcola l'arcoseno di x. Restituisce `NULL` se x non è compreso nell'intervallo da -1 a 1. **Tipo di argomento**: INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione**: DOUBLE **Esempio**: ``` os> source=people | eval `ACOS(0)` = ACOS(0) | fields `ACOS(0)` fetched rows / total rows = 1/1 +--------------------+ | ACOS(0) | |--------------------| | 1.5707963267948966 | +--------------------+ ``` ##### `ASIN` **Utilizzo**: `asin(x)` calcola l'arcoseno di x. Restituisce `NULL` se x non è compreso nell'intervallo da -1 a 1. **Tipo di argomento**: INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione**: DOUBLE **Esempio**: ``` os> source=people | eval `ASIN(0)` = ASIN(0) | fields `ASIN(0)` fetched rows / total rows = 1/1 +-----------+ | ASIN(0) | |-----------| | 0.0 | +-----------+ ``` ##### `ATAN` **Uso**: `ATAN(x)` calcola l'arcotangente di x. `atan(y, x)` Calcola l'arcotangente di y/x, tranne per il fatto che i segni di entrambi gli argomenti determinano il quadrante del risultato. **Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione**: DOUBLE **Esempio**: ``` os> source=people | eval `ATAN(2)` = ATAN(2), `ATAN(2, 3)` = ATAN(2, 3) | fields `ATAN(2)`, `ATAN(2, 3)` fetched rows / total rows = 1/1 +--------------------+--------------------+ | ATAN(2) | ATAN(2, 3) | |--------------------+--------------------| | 1.1071487177940904 | 0.5880026035475675 | +--------------------+--------------------+ ``` ##### `ATAN2` **Utilizzo**: `ATAN2(y, x)` calcola l'arcotangente di y/x, tranne per il fatto che i segni di entrambi gli argomenti determinano il quadrante del risultato. **Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione**: DOUBLE **Esempio**: ``` os> source=people | eval `ATAN2(2, 3)` = ATAN2(2, 3) | fields `ATAN2(2, 3)` fetched rows / total rows = 1/1 +--------------------+ | ATAN2(2, 3) | |--------------------| | 0.5880026035475675 | +--------------------+ ``` ##### `CBRT` **Utilizzo**: `CBRT` calcola la radice cubica di un numero. Tipo di **argomento**: INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione**: DOUBLE: INTEGER/LONG/FLOAT/DOUBLE-> DOPPIO **Esempio**: ``` opensearchsql> source=location | eval `CBRT(8)` = CBRT(8), `CBRT(9.261)` = CBRT(9.261), `CBRT(-27)` = CBRT(-27) | fields `CBRT(8)`, `CBRT(9.261)`, `CBRT(-27)`; fetched rows / total rows = 2/2 +-----------+---------------+-------------+ | CBRT(8) | CBRT(9.261) | CBRT(-27) | |-----------+---------------+-------------| | 2.0 | 2.1 | -3.0 | | 2.0 | 2.1 | -3.0 | +-----------+---------------+-------------+ ``` ##### `CEIL` **Utilizzo**: un alias per la `CEILING` funzione. `CEILING(T)`prende il limite del valore T. **Limitazione**: funziona `CEILING` solo come previsto quando il tipo doppio IEEE 754 visualizza un decimale quando memorizzato. **Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione**: LUNGO **Esempio**: ``` os> source=people | eval `CEILING(0)` = CEILING(0), `CEILING(50.00005)` = CEILING(50.00005), `CEILING(-50.00005)` = CEILING(-50.00005) | fields `CEILING(0)`, `CEILING(50.00005)`, `CEILING(-50.00005)` fetched rows / total rows = 1/1 +--------------+---------------------+----------------------+ | CEILING(0) | CEILING(50.00005) | CEILING(-50.00005) | |--------------+---------------------+----------------------| | 0 | 51 | -50 | +--------------+---------------------+----------------------+ os> source=people | eval `CEILING(3147483647.12345)` = CEILING(3147483647.12345), `CEILING(113147483647.12345)` = CEILING(113147483647.12345), `CEILING(3147483647.00001)` = CEILING(3147483647.00001) | fields `CEILING(3147483647.12345)`, `CEILING(113147483647.12345)`, `CEILING(3147483647.00001)` fetched rows / total rows = 1/1 +-----------------------------+-------------------------------+-----------------------------+ | CEILING(3147483647.12345) | CEILING(113147483647.12345) | CEILING(3147483647.00001) | |-----------------------------+-------------------------------+-----------------------------| | 3147483648 | 113147483648 | 3147483648 | +-----------------------------+-------------------------------+-----------------------------+ ``` ##### `CONV` **Utilizzo**: `CONV(x, a, b)` converte il numero x da una base a una base b. **Tipo di argomento**: x: STRING, a: INTEGER, b: INTEGER **Tipo restituito: STRING** **Esempio**: ``` os> source=people | eval `CONV('12', 10, 16)` = CONV('12', 10, 16), `CONV('2C', 16, 10)` = CONV('2C', 16, 10), `CONV(12, 10, 2)` = CONV(12, 10, 2), `CONV(1111, 2, 10)` = CONV(1111, 2, 10) | fields `CONV('12', 10, 16)`, `CONV('2C', 16, 10)`, `CONV(12, 10, 2)`, `CONV(1111, 2, 10)` fetched rows / total rows = 1/1 +----------------------+----------------------+-------------------+---------------------+ | CONV('12', 10, 16) | CONV('2C', 16, 10) | CONV(12, 10, 2) | CONV(1111, 2, 10) | |----------------------+----------------------+-------------------+---------------------| | c | 44 | 1100 | 15 | +----------------------+----------------------+-------------------+---------------------+ ``` ##### `COS` **Utilizzo**: `COS(x)` calcola il coseno di x, dove x è espresso in radianti. **Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione:** DOUBLE **Esempio**: ``` os> source=people | eval `COS(0)` = COS(0) | fields `COS(0)` fetched rows / total rows = 1/1 +----------+ | COS(0) | |----------| | 1.0 | +----------+ ``` ##### `COT` **Utilizzo**: `COT(x)` calcola la cotangente di x. Restituisce out-of-range un errore se x è uguale a 0. **Tipo di argomento**: INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione**: DOUBLE **Esempio**: ``` os> source=people | eval `COT(1)` = COT(1) | fields `COT(1)` fetched rows / total rows = 1/1 +--------------------+ | COT(1) | |--------------------| | 0.6420926159343306 | +--------------------+ ``` ##### `CRC32` **Utilizzo**: `CRC32` calcola un valore di controllo di ridondanza ciclico e restituisce un valore senza segno a 32 bit. **Tipo** di argomento: STRING **Tipo restituito**: LONG **Esempio**: ``` os> source=people | eval `CRC32('MySQL')` = CRC32('MySQL') | fields `CRC32('MySQL')` fetched rows / total rows = 1/1 +------------------+ | CRC32('MySQL') | |------------------| | 3259397556 | +------------------+ ``` ##### `DEGREES` **Utilizzo**: `DEGREES(x)` converte x da radianti a gradi. Tipo di **argomento**: INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione**: DOUBLE **Esempio**: ``` os> source=people | eval `DEGREES(1.57)` = DEGREES(1.57) | fields `DEGREES(1.57)` fetched rows / total rows = 1/1 +-------------------+ | DEGREES(1.57) | |-------------------| | 89.95437383553924 | +-------------------+ ``` ##### `E` **Utilizzo**: `E()` restituisce il numero di Eulero. **Tipo di restituzione**: DOUBLE **Esempio**: ``` os> source=people | eval `E()` = E() | fields `E()` fetched rows / total rows = 1/1 +-------------------+ | E() | |-------------------| | 2.718281828459045 | +-------------------+ ``` ##### `EXP` **Utilizzo**: `EXP(x)` restituisce e elevato alla potenza di x. **Tipo di argomento**: INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione**: DOUBLE **Esempio**: ``` os> source=people | eval `EXP(2)` = EXP(2) | fields `EXP(2)` fetched rows / total rows = 1/1 +------------------+ | EXP(2) | |------------------| | 7.38905609893065 | +------------------+ ``` ##### `FLOOR` **Utilizzo**: `FLOOR(T)` prende il nome dal valore T. **Limitazione**: funziona `FLOOR` solo come previsto quando il tipo doppio IEEE 754 visualizza un decimale quando memorizzato. **Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione**: LUNGO **Esempio**: ``` os> source=people | eval `FLOOR(0)` = FLOOR(0), `FLOOR(50.00005)` = FLOOR(50.00005), `FLOOR(-50.00005)` = FLOOR(-50.00005) | fields `FLOOR(0)`, `FLOOR(50.00005)`, `FLOOR(-50.00005)` fetched rows / total rows = 1/1 +------------+-------------------+--------------------+ | FLOOR(0) | FLOOR(50.00005) | FLOOR(-50.00005) | |------------+-------------------+--------------------| | 0 | 50 | -51 | +------------+-------------------+--------------------+ os> source=people | eval `FLOOR(3147483647.12345)` = FLOOR(3147483647.12345), `FLOOR(113147483647.12345)` = FLOOR(113147483647.12345), `FLOOR(3147483647.00001)` = FLOOR(3147483647.00001) | fields `FLOOR(3147483647.12345)`, `FLOOR(113147483647.12345)`, `FLOOR(3147483647.00001)` fetched rows / total rows = 1/1 +---------------------------+-----------------------------+---------------------------+ | FLOOR(3147483647.12345) | FLOOR(113147483647.12345) | FLOOR(3147483647.00001) | |---------------------------+-----------------------------+---------------------------| | 3147483647 | 113147483647 | 3147483647 | +---------------------------+-----------------------------+---------------------------+ os> source=people | eval `FLOOR(282474973688888.022)` = FLOOR(282474973688888.022), `FLOOR(9223372036854775807.022)` = FLOOR(9223372036854775807.022), `FLOOR(9223372036854775807.0000001)` = FLOOR(9223372036854775807.0000001) | fields `FLOOR(282474973688888.022)`, `FLOOR(9223372036854775807.022)`, `FLOOR(9223372036854775807.0000001)` fetched rows / total rows = 1/1 +------------------------------+----------------------------------+--------------------------------------+ | FLOOR(282474973688888.022) | FLOOR(9223372036854775807.022) | FLOOR(9223372036854775807.0000001) | |------------------------------+----------------------------------+--------------------------------------| | 282474973688888 | 9223372036854775807 | 9223372036854775807 | +------------------------------+----------------------------------+--------------------------------------+ ``` ##### `LN` **Utilizzo**: `LN(x)` restituisce il logaritmo naturale di x. Tipo di **argomento**: INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione**: DOUBLE **Esempio**: ``` os> source=people | eval `LN(2)` = LN(2) | fields `LN(2)` fetched rows / total rows = 1/1 +--------------------+ | LN(2) | |--------------------| | 0.6931471805599453 | +--------------------+ ``` ##### `LOG` **Utilizzo**: `LOG(x)` restituisce il logaritmo naturale di x che è il logaritmo di base e di x. log (B, x) è equivalente a log (x) /log (B). **Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione**: DOUBLE **Esempio**: ``` os> source=people | eval `LOG(2)` = LOG(2), `LOG(2, 8)` = LOG(2, 8) | fields `LOG(2)`, `LOG(2, 8)` fetched rows / total rows = 1/1 +--------------------+-------------+ | LOG(2) | LOG(2, 8) | |--------------------+-------------| | 0.6931471805599453 | 3.0 | +--------------------+-------------+ ``` ##### `LOG2` **Utilizzo**: `LOG2(x)` è equivalente a`log(x)`/`log(2)`. **Tipo di argomento**: INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione**: DOUBLE **Esempio**: ``` os> source=people | eval `LOG2(8)` = LOG2(8) | fields `LOG2(8)` fetched rows / total rows = 1/1 +-----------+ | LOG2(8) | |-----------| | 3.0 | +-----------+ ``` ##### `LOG10` **Utilizzo**: `LOG10(x)` è equivalente a`log(x)`/`log(10)`. **Tipo di argomento**: INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione**: DOUBLE **Esempio**: ``` os> source=people | eval `LOG10(100)` = LOG10(100) | fields `LOG10(100)` fetched rows / total rows = 1/1 +--------------+ | LOG10(100) | |--------------| | 2.0 | +--------------+ ``` ##### `MOD` **Utilizzo**: `MOD(n, m)` calcola il resto del numero n diviso per m. Tipo di **argomento**: INTEGER/LONG/FLOAT/DOUBLE **Tipo restituito**: tipo più ampio tra i tipi n e m se m è un valore diverso da zero. Se m è uguale a 0, restituisce NULL. **Esempio**: ``` os> source=people | eval `MOD(3, 2)` = MOD(3, 2), `MOD(3.1, 2)` = MOD(3.1, 2) | fields `MOD(3, 2)`, `MOD(3.1, 2)` fetched rows / total rows = 1/1 +-------------+---------------+ | MOD(3, 2) | MOD(3.1, 2) | |-------------+---------------| | 1 | 1.1 | +-------------+---------------+ ``` ##### `PI` **Utilizzo**: `PI() ` restituisce la costante pi. **Tipo di restituzione**: DOUBLE **Esempio**: ``` os> source=people | eval `PI()` = PI() | fields `PI()` fetched rows / total rows = 1/1 +-------------------+ | PI() | |-------------------| | 3.141592653589793 | +-------------------+ ``` ##### `POW` **Utilizzo**: `POW(x, y)` calcola il valore di x elevato alla potenza di y. Gli input errati restituiscono un `NULL` risultato. **Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione**: DOUBLE **Sinonimi**: `POWER(_, _)` **Esempio**: ``` os> source=people | eval `POW(3, 2)` = POW(3, 2), `POW(-3, 2)` = POW(-3, 2), `POW(3, -2)` = POW(3, -2) | fields `POW(3, 2)`, `POW(-3, 2)`, `POW(3, -2)` fetched rows / total rows = 1/1 +-------------+--------------+--------------------+ | POW(3, 2) | POW(-3, 2) | POW(3, -2) | |-------------+--------------+--------------------| | 9.0 | 9.0 | 0.1111111111111111 | +-------------+--------------+--------------------+ ``` ##### POWER **Utilizzo**: `POWER(x, y)` calcola il valore di x elevato alla potenza di y. Gli input errati restituiscono un `NULL` risultato. **Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione**: DOUBLE **Sinonimi**: `POW(_, _)` **Esempio**: ``` os> source=people | eval `POWER(3, 2)` = POWER(3, 2), `POWER(-3, 2)` = POWER(-3, 2), `POWER(3, -2)` = POWER(3, -2) | fields `POWER(3, 2)`, `POWER(-3, 2)`, `POWER(3, -2)` fetched rows / total rows = 1/1 +---------------+----------------+--------------------+ | POWER(3, 2) | POWER(-3, 2) | POWER(3, -2) | |---------------+----------------+--------------------| | 9.0 | 9.0 | 0.1111111111111111 | +---------------+----------------+--------------------+ ``` ##### `RADIANS` **Utilizzo**: `RADIANS(x)` converte x da gradi a radianti. Tipo di **argomento**: INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione**: DOUBLE **Esempio**: ``` os> source=people | eval `RADIANS(90)` = RADIANS(90) | fields `RADIANS(90)` fetched rows / total rows = 1/1 +--------------------+ | RADIANS(90) | |--------------------| | 1.5707963267948966 | +--------------------+ ``` ##### `RAND` **Utilizzo**:`RAND()`/`RAND(N)`restituisce un valore casuale a virgola mobile nell'intervallo 0 <= valore < 1,0. Se specificate il numero intero N, la funzione inizializza il seme prima dell'esecuzione. Un'implicazione di questo comportamento è che con un argomento identico N, `rand(N)` restituisce lo stesso valore ogni volta, producendo una sequenza ripetibile di valori di colonna. **Tipo di argomento: INTERO** **Tipo restituito: FLOAT** **Esempio**: ``` os> source=people | eval `RAND(3)` = RAND(3) | fields `RAND(3)` fetched rows / total rows = 1/1 +------------+ | RAND(3) | |------------| | 0.73105735 | +------------+ ``` ##### `ROUND` **Utilizzo**: `ROUND(x, d)` arrotonda l'argomento x a d cifre decimali. Se non si specifica d, il valore predefinito è 0. Tipo di **argomento**: INTEGER/LONG/FLOAT/DOUBLE **Mappa del tipo di ritorno**: + (INTEGER/LONG [, INTEGER]) -> LONG + (FLOAT/DOUBLE [, INTERO]) -> LUNGO **Esempio**: ``` os> source=people | eval `ROUND(12.34)` = ROUND(12.34), `ROUND(12.34, 1)` = ROUND(12.34, 1), `ROUND(12.34, -1)` = ROUND(12.34, -1), `ROUND(12, 1)` = ROUND(12, 1) | fields `ROUND(12.34)`, `ROUND(12.34, 1)`, `ROUND(12.34, -1)`, `ROUND(12, 1)` fetched rows / total rows = 1/1 +----------------+-------------------+--------------------+----------------+ | ROUND(12.34) | ROUND(12.34, 1) | ROUND(12.34, -1) | ROUND(12, 1) | |----------------+-------------------+--------------------+----------------| | 12.0 | 12.3 | 10.0 | 12 | +----------------+-------------------+--------------------+----------------+ ``` ##### `SIGN` **Utilizzo**: `SIGN` restituisce il segno dell'argomento come -1, 0 o 1, a seconda che il numero sia negativo, zero o positivo. **Tipo di argomento**: INTEGER/LONG/FLOAT/DOUBLE **Tipo restituito:** INTEGER **Esempio**: ``` os> source=people | eval `SIGN(1)` = SIGN(1), `SIGN(0)` = SIGN(0), `SIGN(-1.1)` = SIGN(-1.1) | fields `SIGN(1)`, `SIGN(0)`, `SIGN(-1.1)` fetched rows / total rows = 1/1 +-----------+-----------+--------------+ | SIGN(1) | SIGN(0) | SIGN(-1.1) | |-----------+-----------+--------------| | 1 | 0 | -1 | +-----------+-----------+--------------+ ``` ##### `SIN` **Utilizzo**: `sin(x)` calcola il seno di x, dove x è espresso in radianti. **Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE **Tipo di restituzione:** DOUBLE **Esempio**: ``` os> source=people | eval `SIN(0)` = SIN(0) | fields `SIN(0)` fetched rows / total rows = 1/1 +----------+ | SIN(0) | |----------| | 0.0 | +----------+ ``` ##### `SQRT` **Utilizzo**: `SQRT` calcola la radice quadrata di un numero non negativo. **Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE **Mappa del tipo di ritorno:** + (Non negativo) INTEGER/LONG/FLOAT/DOUBLE -> DOUBLE + (Negativo) INTEGER/LONG/FLOAT/DOUBLE -> NULL **Esempio**: ``` os> source=people | eval `SQRT(4)` = SQRT(4), `SQRT(4.41)` = SQRT(4.41) | fields `SQRT(4)`, `SQRT(4.41)` fetched rows / total rows = 1/1 +-----------+--------------+ | SQRT(4) | SQRT(4.41) | |-----------+--------------| | 2.0 | 2.1 | +-----------+--------------+ ``` ##### Funzioni di stringa PPL **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions) ##### `CONCAT` **Utilizzo**: `CONCAT(str1, str2, ...., str_9)` somma fino a 9 stringhe insieme. **Tipo di argomento:** + STRINGA, STRINGA,..., STRINGA + Tipo restituito: STRING **Esempio**: ``` os> source=people | eval `CONCAT('hello', 'world')` = CONCAT('hello', 'world'), `CONCAT('hello ', 'whole ', 'world', '!')` = CONCAT('hello ', 'whole ', 'world', '!') | fields `CONCAT('hello', 'world')`, `CONCAT('hello ', 'whole ', 'world', '!')` fetched rows / total rows = 1/1 +----------------------------+--------------------------------------------+ | CONCAT('hello', 'world') | CONCAT('hello ', 'whole ', 'world', '!') | |----------------------------+--------------------------------------------| | helloworld | hello whole world! | +----------------------------+--------------------------------------------+ ``` ##### `CONCAT_WS` **Utilizzo**: `CONCAT_WS(sep, str1, str2)` concatena due o più stringhe utilizzando un separatore specificato tra di loro. **Tipo di argomento:** + STRINGA, STRINGA,..., STRINGA + Tipo restituito: STRING **Esempio**: ``` os> source=people | eval `CONCAT_WS(',', 'hello', 'world')` = CONCAT_WS(',', 'hello', 'world') | fields `CONCAT_WS(',', 'hello', 'world')` fetched rows / total rows = 1/1 +------------------------------------+ | CONCAT_WS(',', 'hello', 'world') | |------------------------------------| | hello,world | +------------------------------------+ ``` ##### `LENGTH` **Utilizzo**: `length(str)` restituisce la lunghezza della stringa di input misurata in byte. **Tipo di argomento:** + STRING + Tipo restituito: INTEGER **Esempio**: ``` os> source=people | eval `LENGTH('helloworld')` = LENGTH('helloworld') | fields `LENGTH('helloworld')` fetched rows / total rows = 1/1 +------------------------+ | LENGTH('helloworld') | |------------------------| | 10 | +------------------------+ ``` ##### `LOWER` **Utilizzo**: `lower(string)` converte la stringa di input in lettere minuscole. **Tipo di argomento:** + STRING + Tipo restituito: STRING **Esempio**: ``` os> source=people | eval `LOWER('helloworld')` = LOWER('helloworld'), `LOWER('HELLOWORLD')` = LOWER('HELLOWORLD') | fields `LOWER('helloworld')`, `LOWER('HELLOWORLD')` fetched rows / total rows = 1/1 +-----------------------+-----------------------+ | LOWER('helloworld') | LOWER('HELLOWORLD') | |-----------------------+-----------------------| | helloworld | helloworld | +-----------------------+-----------------------+ ``` ##### `LTRIM` **Utilizzo**: `ltrim(str)` rimuove i caratteri spaziali iniziali dalla stringa di input. **Tipo di argomento:** + STRING + Tipo restituito: STRING **Esempio**: ``` os> source=people | eval `LTRIM(' hello')` = LTRIM(' hello'), `LTRIM('hello ')` = LTRIM('hello ') | fields `LTRIM(' hello')`, `LTRIM('hello ')` fetched rows / total rows = 1/1 +---------------------+---------------------+ | LTRIM(' hello') | LTRIM('hello ') | |---------------------+---------------------| | hello | hello | +---------------------+---------------------+ ``` ##### `POSITION` **Utilizzo**: `POSITION(substr IN str)` restituisce la posizione della prima occorrenza della sottostringa nella stringa. Restituisce 0 se la sottostringa non è nella stringa. Restituisce NULL se un argomento è NULL. **Tipo di argomento:** + STRINGA, STRINGA + Tipo restituito INTEGER **Esempio**: ``` os> source=people | eval `POSITION('world' IN 'helloworld')` = POSITION('world' IN 'helloworld'), `POSITION('invalid' IN 'helloworld')`= POSITION('invalid' IN 'helloworld') | fields `POSITION('world' IN 'helloworld')`, `POSITION('invalid' IN 'helloworld')` fetched rows / total rows = 1/1 +-------------------------------------+---------------------------------------+ | POSITION('world' IN 'helloworld') | POSITION('invalid' IN 'helloworld') | |-------------------------------------+---------------------------------------| | 6 | 0 | +-------------------------------------+---------------------------------------+ ``` ##### `REVERSE` **Utilizzo**: `REVERSE(str)` restituisce la stringa invertita della stringa di input. **Tipo di argomento:** + STRING + Tipo restituito: STRING **Esempio**: ``` os> source=people | eval `REVERSE('abcde')` = REVERSE('abcde') | fields `REVERSE('abcde')` fetched rows / total rows = 1/1 +--------------------+ | REVERSE('abcde') | |--------------------| | edcba | +--------------------+ ``` ##### `RIGHT` **Utilizzo**: `right(str, len)` restituisce i caratteri più a destra della stringa di input. Restituisce 0 se la sottostringa non è nella stringa. Restituisce NULL se un argomento è NULL. **Tipo di argomento:** + STRINGA, NUMERO INTERO + Tipo restituito: STRING **Esempio**: ``` os> source=people | eval `RIGHT('helloworld', 5)` = RIGHT('helloworld', 5), `RIGHT('HELLOWORLD', 0)` = RIGHT('HELLOWORLD', 0) | fields `RIGHT('helloworld', 5)`, `RIGHT('HELLOWORLD', 0)` fetched rows / total rows = 1/1 +--------------------------+--------------------------+ | RIGHT('helloworld', 5) | RIGHT('HELLOWORLD', 0) | |--------------------------+--------------------------| | world | | +--------------------------+--------------------------+ ``` ##### `RTRIM` **Utilizzo**: `rtrim(str)` elimina i caratteri spaziali finali dalla stringa di input. **Tipo di argomento:** + STRING + Tipo restituito: **STRING** **Esempio**: ``` os> source=people | eval `RTRIM(' hello')` = RTRIM(' hello'), `RTRIM('hello ')` = RTRIM('hello ') | fields `RTRIM(' hello')`, `RTRIM('hello ')` fetched rows / total rows = 1/1 +---------------------+---------------------+ | RTRIM(' hello') | RTRIM('hello ') | |---------------------+---------------------| | hello | hello | +---------------------+---------------------+ ``` ##### `SUBSTRING` **Utilizzo**: `substring(str, start)` o `substring(str, start, length)` restituisce una sottostringa della stringa di input. Senza una lunghezza specificata, restituisce l'intera stringa dalla posizione iniziale. **Tipo di argomento:** + STRINGA, NUMERO INTERO, NUMERO INTERO + Tipo restituito: STRING **Esempio**: ``` os> source=people | eval `SUBSTRING('helloworld', 5)` = SUBSTRING('helloworld', 5), `SUBSTRING('helloworld', 5, 3)` = SUBSTRING('helloworld', 5, 3) | fields `SUBSTRING('helloworld', 5)`, `SUBSTRING('helloworld', 5, 3)` fetched rows / total rows = 1/1 +------------------------------+---------------------------------+ | SUBSTRING('helloworld', 5) | SUBSTRING('helloworld', 5, 3) | |------------------------------+---------------------------------| | oworld | owo | +------------------------------+---------------------------------+ ``` ##### `TRIM` **Utilizzo**: `trim(string)` rimuove gli spazi bianchi iniziali e finali dalla stringa di input. **Tipo di argomento:** + STRING + Tipo restituito: **STRING** **Esempio**: ``` os> source=people | eval `TRIM(' hello')` = TRIM(' hello'), `TRIM('hello ')` = TRIM('hello ') | fields `TRIM(' hello')`, `TRIM('hello ')` fetched rows / total rows = 1/1 +--------------------+--------------------+ | TRIM(' hello') | TRIM('hello ') | |--------------------+--------------------| | hello | hello | +--------------------+--------------------+ ``` ##### `UPPER` **Utilizzo**: `upper(string)` converte la stringa di input in maiuscolo. **Tipo di argomento:** + STRING + Tipo restituito: STRING **Esempio**: ``` os> source=people | eval `UPPER('helloworld')` = UPPER('helloworld'), `UPPER('HELLOWORLD')` = UPPER('HELLOWORLD') | fields `UPPER('helloworld')`, `UPPER('HELLOWORLD')` fetched rows / total rows = 1/1 +-----------------------+-----------------------+ | UPPER('helloworld') | UPPER('HELLOWORLD') | |-----------------------+-----------------------| | HELLOWORLD | HELLOWORLD | +-----------------------+-----------------------+ ``` ##### Funzioni di conversione di tipo PPL **Nota** Per vedere quali integrazioni di fonti di AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions) ##### `TRIM` **Utilizzo**: `cast(expr as dateType)` trasmette il `expr` a `dataType` e restituisce il valore di. `dataType` Si applicano le seguenti regole di conversione: **Regole di conversione dei tipi** | Src/Target | STRING | NUMBER | BOOLEAN | TIMESTAMP | DATE | TIME | | --- | --- | --- | --- | --- | --- | --- | | STRING | | Nota 1 | Nota 1 | TIMESTAMP() | DATE() | TIME() | | NUMBER | Nota 1 | | v\$1 =0 | N/D | N/D | N/D | | BOOLEAN | Nota 1 | v? 1:0 | | N/D | N/D | N/D | | TIMESTAMP | Nota 1 | N/D | N/D | | DATE() | TIME() | | DATE | Nota 1 | N/D | N/D | N/D | | N/D | | TIME | Nota 1 | N/D | N/D | N/D | N/D | | **Esempio di cast su stringa:** ``` os> source=people | eval `cbool` = CAST(true as string), `cint` = CAST(1 as string), `cdate` = CAST(CAST('2012-08-07' as date) as string) | fields `cbool`, `cint`, `cdate` fetched rows / total rows = 1/1 +---------+--------+------------+ | cbool | cint | cdate | |---------+--------+------------| | true | 1 | 2012-08-07 | +---------+--------+------------+ ``` **Esempio di cast to number:** ``` os> source=people | eval `cbool` = CAST(true as int), `cstring` = CAST('1' as int) | fields `cbool`, `cstring` fetched rows / total rows = 1/1 +---------+-----------+ | cbool | cstring | |---------+-----------| | 1 | 1 | +---------+-----------+ ``` **Esempio di cast to date:** ``` os> source=people | eval `cdate` = CAST('2012-08-07' as date), `ctime` = CAST('01:01:01' as time), `ctimestamp` = CAST('2012-08-07 01:01:01' as timestamp) | fields `cdate`, `ctime`, `ctimestamp` fetched rows / total rows = 1/1 +------------+----------+---------------------+ | cdate | ctime | ctimestamp | |------------+----------+---------------------| | 2012-08-07 | 01:01:01 | 2012-08-07 01:01:01 | +------------+----------+---------------------+ ``` **Esempio di cast concatenato:** ``` os> source=people | eval `cbool` = CAST(CAST(true as string) as boolean) | fields `cbool` fetched rows / total rows = 1/1 +---------+ | cbool | |---------| | True | +---------+ ```