Questa pagina è stata tradotta dall'API Cloud Translation.

Guida alla traduzione SQL di Oracle

Questo documento illustra le analogie e le differenze nella sintassi SQL tra Oracle e BigQuery per aiutarti a pianificare la migrazione. Utilizza la traduzione SQL batch per eseguire la migrazione collettiva degli script SQL o la traduzione SQL interattiva per tradurre le query ad hoc.

Tipi di dati

Questa sezione mostra gli equivalenti tra i tipi di dati in Oracle e in BigQuery.

Oracle	BigQuery	Note
`VARCHAR2`	`STRING`
`NVARCHAR2`	`STRING`
`CHAR`	`STRING`
`NCHAR`	`STRING`
`CLOB`	`STRING`
`NCLOB`	`STRING`
`INTEGER`	`INT64`
`SHORTINTEGER`	`INT64`
`LONGINTEGER`	`INT64`
`NUMBER`	`NUMERIC`	BigQuery non consente all'utente di specificare valori personalizzati per la precisione o la scala. Di conseguenza, una colonna in Oracle può essere definita in modo da avere una scala più grande di quella supportata da BigQuery. Inoltre, prima di memorizzare un numero decimale, Oracle lo arrotonda per eccesso se il numero contiene più cifre decimali di quelle specificate per la colonna corrispondente. In BigQuery questa funzionalità potrebbe essere implementata utilizzando la funzione `ROUND()`.
`NUMBER(*, x)`	`NUMERIC`	BigQuery non consente all'utente di specificare valori personalizzati per la precisione o la scala. Di conseguenza, una colonna in Oracle può essere definita in modo da avere una scala più grande di quella supportata da BigQuery. Inoltre, prima di memorizzare un numero decimale, Oracle lo arrotonda per eccesso se il numero contiene più cifre decimali di quelle specificate per la colonna corrispondente. In BigQuery questa funzionalità potrebbe essere implementata utilizzando la funzione `ROUND()`.
`NUMBER(x, -y)`	`INT64`	Se un utente tenta di memorizzare un numero decimale, Oracle lo arrotonda per eccesso a un numero intero. Per BigQuery, il tentativo di archiviare un numero decimale in una colonna definita come `INT64` genera un errore. In questo caso, deve essere applicata la funzione `ROUND()`. I tipi di dati `INT64` di BigQuery consentono fino a 18 cifre di precisione. Se un campo numerico contiene più di 18 cifre, in BigQuery deve essere utilizzato il tipo di dati `FLOAT64`.
`NUMBER(x)`	`INT64`	Se un utente tenta di memorizzare un numero decimale, Oracle lo arrotonda per eccesso a un numero intero. Per BigQuery, il tentativo di memorizzare un numero decimale in una colonna definita come `INT64` genera un errore. In questo caso, deve essere applicata la funzione `ROUND()`. I tipi di dati `INT64` di BigQuery consentono fino a 18 cifre di precisione. Se un campo numerico contiene più di 18 cifre, in BigQuery deve essere utilizzato il tipo di dati `FLOAT64`.
`FLOAT`	`FLOAT64`/`NUMERIC`	`FLOAT` è un tipo di dati esatto ed è un sottotipo di `NUMBER` in Oracle. In BigQuery, `FLOAT64` è un tipo di dati approssimativo. `NUMERIC` potrebbe essere una corrispondenza migliore per il tipo `FLOAT` in BigQuery.
`BINARY_DOUBLE`	`FLOAT64`/`NUMERIC`	`FLOAT` è un tipo di dati esatto ed è un sottotipo di `NUMBER` in Oracle. In BigQuery, `FLOAT64` è un tipo di dati approssimativo. `NUMERIC` potrebbe essere una corrispondenza migliore per il tipo `FLOAT` in BigQuery.
`BINARY_FLOAT`	`FLOAT64`/`NUMERIC`	`FLOAT` è un tipo di dati esatto ed è un sottotipo di `NUMBER` in Oracle. In BigQuery, `FLOAT64` è un tipo di dati approssimativo. `NUMERIC` potrebbe essere una corrispondenza migliore per il tipo `FLOAT` in BigQuery.
`LONG`	`BYTES`	Il tipo di dati `LONG` viene utilizzato nelle versioni precedenti e non è consigliato nelle nuove versioni di Oracle Database. Il tipo di dati `BYTES` in BigQuery può essere utilizzato se è necessario conservare i dati `LONG` in BigQuery. Un approccio migliore consisterebbe nell'inserire gli oggetti binari in Cloud Storage e conservare i riferimenti in BigQuery.
`BLOB`	`BYTES`	Il tipo di dati `BYTES` può essere utilizzato per memorizzare dati binari di lunghezza variabile. Se questo campo non viene sottoposto a query e non viene utilizzato in analisi, un'opzione migliore è archiviare i dati binari in Cloud Storage.
`BFILE`	`STRING`	I file binari possono essere archiviati in Cloud Storage e il tipo di dati `STRING` può essere utilizzato per fare riferimento ai file in una tabella BigQuery.
`DATE`	`DATETIME`
`TIMESTAMP`	`TIMESTAMP`	BigQuery supporta una precisione a microsecondi (10^-6) rispetto a Oracle, che supporta una precisione da 0 a 9. BigQuery supporta il nome di una regione del fuso orario da un database TZ e la differenza di fuso orario rispetto a UTC. In BigQuery, la conversione del fuso orario deve essere eseguita manualmente in modo che corrisponda alla funzionalità `TIMESTAMP WITH LOCAL TIME ZONE` di Oracle.
`TIMESTAMP(x)`	`TIMESTAMP`	BigQuery supporta una precisione a microsecondi (10^-6) rispetto a Oracle, che supporta una precisione da 0 a 9. BigQuery supporta il nome di una regione del fuso orario da un database TZ e la differenza di fuso orario rispetto a UTC. In BigQuery, la conversione del fuso orario deve essere eseguita manualmente in modo che corrisponda alla funzionalità `TIMESTAMP WITH LOCAL TIME ZONE` di Oracle.
`TIMESTAMP WITH TIME ZONE`	`TIMESTAMP`	BigQuery supporta una precisione a microsecondi (10^-6) rispetto a Oracle, che supporta una precisione da 0 a 9. BigQuery supporta il nome di una regione del fuso orario da un database TZ e la differenza di fuso orario rispetto a UTC. In BigQuery, la conversione del fuso orario deve essere eseguita manualmente in modo che corrisponda alla funzionalità `TIMESTAMP WITH LOCAL TIME ZONE` di Oracle.
`TIMESTAMP WITH LOCAL TIME ZONE`	`TIMESTAMP`	BigQuery supporta una precisione a microsecondi (10^-6) rispetto a Oracle, che supporta una precisione da 0 a 9. BigQuery supporta il nome di una regione del fuso orario da un database TZ e la differenza di fuso orario rispetto a UTC. In BigQuery, la conversione del fuso orario deve essere eseguita manualmente in modo che corrisponda alla funzionalità `TIMESTAMP WITH LOCAL TIME ZONE` di Oracle.
`INTERVAL YEAR TO MONTH`	`STRING`	I valori intervallo possono essere archiviati come tipo di dati `STRING` in BigQuery.
`INTERVAL DAY TO SECOND`	`STRING`	I valori intervallo possono essere archiviati come tipo di dati `STRING` in BigQuery.
`RAW`	`BYTES`	Il tipo di dati `BYTES` può essere utilizzato per memorizzare dati binari di lunghezza variabile. Se questo campo non viene sottoposto a query e utilizzato in analisi, un'opzione migliore è archiviare i dati binari su Cloud Storage.
`LONG RAW`	`BYTES`	Il tipo di dati `BYTES` può essere utilizzato per memorizzare dati binari di lunghezza variabile. Se questo campo non viene sottoposto a query e utilizzato in analisi, un'opzione migliore è archiviare i dati binari su Cloud Storage.
`ROWID`	`STRING`	Questi tipi di dati vengono utilizzati internamente da Oracle per specificare indirizzi univoci per le righe di una tabella. In genere, il campo `ROWID` o `UROWID` non deve essere utilizzato nelle applicazioni. In questo caso, però, puoi utilizzare il tipo di dati `STRING` per memorizzare questi dati.

Formattazione del testo

Oracle SQL utilizza un insieme di formati predefiniti impostati come parametri per la visualizzazione di espressioni e dati di colonna e per le conversioni tra tipi di dati. Ad esempio, NLS_DATE_FORMAT impostato come YYYY/MM/DD formatta le date come YYYY/MM/DD per impostazione predefinita. Puoi trovare ulteriori informazioni sulle impostazioni NLS nella documentazione online di Oracle. In BigQuery non sono presenti parametri di inizializzazione.

Per impostazione predefinita, BigQuery si aspetta che tutti i dati di origine siano codificati in UTF-8 durante il caricamento. Se hai file CSV con dati codificati in formato ISO-8859-1, puoi specificare esplicitamente la codifica durante l'importazione dei dati in modo che BigQuery possa convertirli correttamente in UTF-8 durante la procedura di importazione.

È possibile importare solo dati con codifica ISO-8859-1 o UTF-8. BigQuery archivia e restituisce i dati con codifica UTF-8. Il formato della data o il fuso orario previsti possono essere impostati nelle funzioni DATE e TIMESTAMP.

Formattazione del tipo di timestamp e data

Quando converti gli elementi di formattazione della data e del timestamp da Oracle a BigQuery, devi prestare attenzione alle differenze di fuso orario tra TIMESTAMP e DATETIME, come riassunto nella tabella seguente.

Tieni presente che non ci sono parentesi nei formati Oracle perché i formati (CURRENT_*) sono parole chiave, non funzioni.

Oracle	BigQuery	Note
`CURRENT_TIMESTAMP`	Le informazioni su `TIMESTAMP` in Oracle possono avere informazioni diverse sul fuso orario, che vengono definite utilizzando `WITH TIME ZONE` nella definizione della colonna o nella variabile di impostazione `TIME_ZONE`.	Se possibile, utilizza la funzione `CURRENT_TIMESTAMP()` che è formattata in formato ISO. Tuttavia, il formato di output mostra sempre il fuso orario UTC. (BigQuery non ha un fuso orario interno). Tieni presente i seguenti dettagli sulle differenze nel formato ISO: `DATETIME` è formattato in base alle convenzioni del canale di output. Nello strumento a riga di comando di BigQuery e nella console di BigQuery, `DATETIME` è formattato utilizzando un separatore `T` in base a RFC 3339. Tuttavia, in Python e Java JDBC viene utilizzato uno spazio come separatore. Se vuoi utilizzare un formato esplicito, utilizza la funzione `FORMAT_DATETIME`(), che esegue un passaggio esplicito a una stringa. Ad esempio, la seguente espressione restituisce sempre un separatore di spazi: `CAST(CURRENT_DATETIME() AS STRING)`
`CURRENT_DATE SYSDATE`	Oracle utilizza due tipi per la data: tipo 12 tipo 13 Oracle utilizza il tipo 12 per l'archiviazione delle date. Questi sono numeri di lunghezza fissa. Oracle utilizza il tipo 13 quando a viene restituito da `SYSDATE or CURRENT_DATE`	BigQuery ha un formato `DATE` separato che restituisce sempre una data nel formato ISO 8601. Non è possibile utilizzare `DATE_FROM_UNIX_DATE` perché si basa sul 1970.
`CURRENT_DATE-3`	I valori di data sono rappresentati come numeri interi. Oracle supporta gli operatori aritmetici per i tipi di date.	Per i tipi di date, utilizza `DATE_ADD`() o `DATE_SUB`(). BigQuery utilizza gli operatori aritmetici per i tipi di dati: `INT64`, `NUMERIC` e `FLOAT64`.
`NLS_DATE_FORMAT`	Imposta il formato della data della sessione o del sistema.	BigQuery utilizza sempre ISO 8601, quindi assicurati di convertire le date e le ore di Oracle.

Sintassi delle query

Questa sezione illustra le differenze nella sintassi delle query tra Oracle e BigQuery.

`SELECT` estratti conto

La maggior parte delle istruzioni SELECT di Oracle è compatibile con BigQuery.

Funzioni, operatori ed espressioni

Le sezioni seguenti elencano le mappature tra le funzioni Oracle e i relativi equivalenti di BigQuery.

Operatori di confronto

Gli operatori di confronto di Oracle e BigQuery sono conformi ad ANSI SQL:2011. Gli operatori di confronto nella tabella seguente sono gli stessi sia in BigQuery sia in Oracle. In BigQuery puoi utilizzare REGEXP_CONTAINS instead of REGEXP_LIKE.

Operatore	Descrizione
`"="`	Uguale
`<>`	Non uguale
`!=`	Non uguale
`>`	Maggiore di
`>=`	Maggiore o uguale a
`<`	Meno di
`<=`	Minore o uguale a
`IN ( )`	Corrisponde a un valore in un elenco
`NOT`	Nega una condizione
`BETWEEN`	All'interno di un intervallo (incluso)
`IS NULL`	`NULL` valore
`IS NOT NULL`	Non è un valore `NULL`
`LIKE`	Corrispondenza di pattern con %
`EXISTS`	La condizione è soddisfatta se la sottoquery restituisce almeno una riga

Gli operatori nella tabella sono gli stessi sia in BigQuery che in Oracle.

Espressioni e funzioni logiche

Oracle	BigQuery
`CASE`	`CASE`
`COALESCE`	`COALESCE(expr1, ..., exprN)`
`DECODE`	`CASE.. WHEN.. END`
`NANVL`	`IFNULL`
`FETCH NEXT>`	`LIMIT`
`NULLIF`	`NULLIF(expression, expression_to_match)`
`NVL`	`IFNULL(expr, 0), COALESCE(exp, 0)`
`NVL2`	`IF(expr, true_result, else_result)`

Funzioni di aggregazione

La tabella seguente mostra le mappature tra le funzioni aggregate, di aggregazione statistica e di approssimazione comuni di Oracle e i relativi equivalenti di BigQuery:

Oracle	BigQuery
`ANY_VALUE` (da Oracle 19c)	`ANY_VALUE`
`APPROX_COUNT`	`HLL_COUNT set of functions with specified precision`
`APPROX_COUNT_DISTINCT`	`APPROX_COUNT_DISTINCT`
`APPROX_COUNT_DISTINCT_AGG`	`APPROX_COUNT_DISTINCT`
`APPROX_COUNT_DISTINCT_DETAIL`	`APPROX_COUNT_DISTINCT`
`APPROX_PERCENTILE(percentile) WITHIN GROUP (ORDER BY expression)`	`APPROX_QUANTILES(expression, 100)[ OFFSET(CAST(TRUNC(percentile * 100) as INT64))]` BigQuery non supporta il resto degli argomenti definiti da Oracle.
<codeAPPROX_PERCENTILE_AGG	`APPROX_QUANTILES(expression, 100)[ OFFSET(CAST(TRUNC(percentile * 100) as INT64))]`
`APPROX_PERCENTILE_DETAIL`	`APPROX_QUANTILES(expression, 100)[OFFSET(CAST(TRUNC(percentile * 100) as INT64))]`
`APPROX_SUM`	`APPROX_TOP_SUM(expression, weight, number)`
`AVG`	`AVG`
`BIT_COMPLEMENT`	Operatore di negazione a livello di bit: ~
`BIT_OR`	`BIT_OR, X \| Y`
`BIT_XOR`	`BIT_XOR, X ^ Y`
`BITAND`	`BIT_AND, X & Y`
`CARDINALITY`	`COUNT`
`COLLECT`	BigQuery non supporta `TYPE AS TABLE OF`. Valuta la possibilità di utilizzare `STRING_AGG()` o `ARRAY_AGG()` in BigQuery
`CORR/CORR_K/` `CORR_S`	`CORR`
`COUNT`	`COUNT`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`FIRST`	Non esiste implicitamente in BigQuery. Valuta la possibilità di utilizzare funzioni definite dall'utente (UDF).
`GROUP_ID`	Non utilizzato in BigQuery
`GROUPING`	Non utilizzato in BigQuery
`GROUPING_ID`	Non utilizzato in BigQuery.
`LAST`	Non esiste implicitamente in BigQuery. Valuta la possibilità di utilizzare le funzioni definite dall'utente.
`LISTAGG`	`STRING_AGG, ARRAY_CONCAT_AGG(expression [ORDER BY key [{ASC\|DESC}] [, ... ]] [LIMIT n])`
`MAX`	`MAX`
`MIN`	`MIN`
`OLAP_CONDITION`	Specifico di Oracle, non esiste in BigQuery.
`OLAP_EXPRESSION`	Specifico di Oracle, non esiste in BigQuery.
`OLAP_EXPRESSION_BOOL`	Specifico di Oracle, non esiste in BigQuery.
`OLAP_EXPRESSION_DATE`	Specifico di Oracle, non esiste in BigQuery.
`OLAP_EXPRESSION_TEXT`	Specifico di Oracle, non esiste in BigQuery.
`OLAP_TABLE`	Specifico di Oracle, non esiste in BigQuery.
`POWERMULTISET`	Specifico di Oracle, non esiste in BigQuery.
`POWERMULTISET_BY_CARDINALITY`	Specifico di Oracle, non esiste in BigQuery.
`QUALIFY`	Specifico di Oracle, non esiste in BigQuery.
`REGR_AVGX`	`AVG(` `IF(dep_var_expr is NULL` `OR ind_var_expr is NULL,` `NULL, ind_var_expr)` `)`
`REGR_AVGY`	`AVG(` `IF(dep_var_expr is NULL` `OR ind_var_expr is NULL,` `NULL, dep_var_expr)` `)`
`REGR_COUNT`	`SUM(` `IF(dep_var_expr is NULL` `OR ind_var_expr is NULL,` `NULL, 1)` `)`
`REGR_INTERCEPT`	`AVG(dep_var_expr) - AVG(ind_var_expr) * (COVAR_SAMP(ind_var_expr,dep_var_expr) / VARIANCE(ind_var_expr) )`
`REGR_R2`	`(COUNT(dep_var_expr) * SUM(ind_var_expr * dep_var_expr) - SUM(dep_var_expr) * SUM(ind_var_expr)) / SQRT( (COUNT(ind_var_expr) * SUM(POWER(ind_var_expr, 2)) * POWER(SUM(ind_var_expr),2)) * (COUNT(dep_var_expr) * SUM(POWER(dep_var_expr, 2)) * POWER(SUM(dep_var_expr), 2)))`
`REGR_SLOPE`	`COVAR_SAMP(ind_var_expr,` `dep_var_expr)` `/ VARIANCE(ind_var_expr)`
`REGR_SXX`	`SUM(POWER(ind_var_expr, 2)) - COUNT(ind_var_expr) * POWER(AVG(ind_var_expr),2)`
`REGR_SXY`	`SUM(ind_var_exprdep_var_expr) - COUNT(ind_var_expr) AVG(ind) * AVG(dep_var_expr)`
`REGR_SYY`	`SUM(POWER(dep_var_expr, 2)) - COUNT(dep_var_expr) * POWER(AVG(dep_var_expr),2)`
`ROLLUP`	`ROLLUP`
`STDDEV_POP`	`STDDEV_POP`
`STDDEV_SAMP`	`STDDEV_SAMP, STDDEV`
`SUM`	`SUM`
`VAR_POP`	`VAR_POP`
`VAR_SAMP`	`VAR_SAMP, VARIANCE`
`WM_CONCAT`	`STRING_AGG`

BigQuery offre le seguenti funzioni aggregate aggiuntive:

Funzioni di analisi

La tabella seguente mostra le mappature tra le funzioni di analisi e di analisi aggregata comuni di Oracle e i relativi equivalenti di BigQuery.

Oracle	BigQuery
`AVG`	`AVG`
`BIT_COMPLEMENT`	Operatore di negazione a livello di bit: ~
`BIT_OR`	`BIT_OR, X \| Y`
`BIT_XOR`	`BIT_XOR, X ^ Y`
`BITAND`	`BIT_AND, X & Y`
`BOOL_TO_INT`	`CAST(X AS INT64)`
`COUNT`	`COUNT`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`CUBE_TABLE`	Non è supportato in BigQuery. Valuta la possibilità di utilizzare uno strumento di BI o una UDF personalizzata
`CUME_DIST`	`CUME_DIST`
`DENSE_RANK(ANSI)`	`DENSE_RANK`
`FEATURE_COMPARE`	Non esiste implicitamente in BigQuery. Valutare la possibilità di utilizzare le funzioni UDF e BigQuery ML
`FEATURE_DETAILS`	Non esiste implicitamente in BigQuery. Valutare la possibilità di utilizzare le funzioni UDF e BigQuery ML
`FEATURE_ID`	Non esiste implicitamente in BigQuery. Valutare la possibilità di utilizzare le funzioni UDF e BigQuery ML
`FEATURE_SET`	Non esiste implicitamente in BigQuery. Valutare la possibilità di utilizzare le funzioni UDF e BigQuery ML
`FEATURE_VALUE`	Non esiste implicitamente in BigQuery. Valutare la possibilità di utilizzare le funzioni UDF e BigQuery ML
`FIRST_VALUE`	`FIRST_VALUE`
`HIER_CAPTION`	Le query gerarchiche non sono supportate in BigQuery.
`HIER_CHILD_COUNT`	Le query gerarchiche non sono supportate in BigQuery.
`HIER_COLUMN`	Le query gerarchiche non sono supportate in BigQuery.
`HIER_DEPTH`	Le query gerarchiche non sono supportate in BigQuery.
`HIER_DESCRIPTION`	Le query gerarchiche non sono supportate in BigQuery.
`HIER_HAS_CHILDREN`	Le query gerarchiche non sono supportate in BigQuery.
`HIER_LEVEL`	Le query gerarchiche non sono supportate in BigQuery.
`HIER_MEMBER_NAME`	Le query gerarchiche non sono supportate in BigQuery.
`HIER_ORDER`	Le query gerarchiche non sono supportate in BigQuery.
`HIER_UNIQUE_MEMBER_NAME`	Le query gerarchiche non sono supportate in BigQuery.
`LAST_VALUE`	`LAST_VALUE`
`LAG`	`LAG`
`LEAD`	`LEAD`
`LISTAGG`	`ARRAY_AGG STRING_AGG ARRAY_CONCAT_AGG`
`MATCH_NUMBER`	Il riconoscimento e il calcolo dei pattern possono essere eseguiti con espressioni regolari e funzioni definite dall'utente in BigQuery
`MATCH_RECOGNIZE`	Il riconoscimento e il calcolo dei pattern possono essere eseguiti con espressioni regolari e funzioni definite dall'utente in BigQuery
`MAX`	`MAX`
`MEDIAN`	`PERCENTILE_CONT(x, 0.5 RESPECT NULLS) OVER()`
`MIN`	`MIN`
`NTH_VALUE`	`NTH_VALUE (value_expression, constant_integer_expression [{RESPECT \| IGNORE} NULLS])`
`NTILE`	`NTILE(constant_integer_expression)`
`PERCENT_RANK PERCENT_RANKM`	`PERCENT_RANK`
`PERCENTILE_CONT PERCENTILE_DISC`	`PERCENTILE_CONT`
`PERCENTILE_CONT PERCENTILE_DISC`	`PERCENTILE_DISC`
`PRESENTNNV`	Specifico di Oracle, non esiste in BigQuery.
`PRESENTV`	Specifico di Oracle, non esiste in BigQuery.
`PREVIOUS`	Specifico di Oracle, non esiste in BigQuery.
`RANK`(ANSI)	`RANK`
`RATIO_TO_REPORT(expr) OVER (partition clause)`	`expr / SUM(expr) OVER (partition clause)`
`ROW_NUMBER`	`ROW_NUMBER`
`STDDEV_POP`	`STDDEV_POP`
`STDDEV_SAMP`	`STDDEV_SAMP, STDDEV`
`SUM`	`SUM`
`VAR_POP`	`VAR_POP`
`VAR_SAMP`	`VAR_SAMP, VARIANCE`
`VARIANCE`	`VARIANCE()`
`WIDTH_BUCKET`	È possibile utilizzare le funzioni definite dall'utente.

Funzioni di data/ora

La tabella seguente mostra le mappature tra le funzioni di data/ora Oracle comuni e i relativi equivalenti BigQuery.

Oracle	BigQuery
`ADD_MONTHS(date, integer)`	`DATE_ADD(date, INTERVAL integer MONTH),` Se la data è un `TIMESTAMP`, puoi utilizzare `EXTRACT(DATE FROM TIMESTAMP_ADD(date, INTERVAL integer MONTH))`
`CURRENT_DATE`	`CURRENT_DATE`
`CURRENT_TIME`	`CURRENT_TIME`
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`
`DATE - k`	`DATE_SUB(date_expression, INTERVAL k DAY)`
`DATE + k`	`DATE_ADD(date_expression, INTERVAL k DAY)`
`DBTIMEZONE`	BigQuery non supporta il fuso orario del database.
`EXTRACT`	`EXTRACT(DATE), EXTRACT(TIMESTAMP)`
`LAST_DAY`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 MONTH ), MONTH ), INTERVAL 1 DAY )`
`LOCALTIMESTAMP`	BigQuery non supporta le impostazioni del fuso orario.
`MONTHS_BETWEEN`	`DATE_DIFF(date_expression, date_expression, MONTH)`
`NEW_TIME`	`DATE(timestamp_expression, time zone) TIME(timestamp, time zone) DATETIME(timestamp_expression, time zone)`
`NEXT_DAY`	`DATE_ADD( DATE_TRUNC( date_expression, WEEK(day_value) ), INTERVAL 1 WEEK )`
`SYS_AT_TIME_ZONE`	`CURRENT_DATE([time_zone])`
`SYSDATE`	`CURRENT_DATE()`
`SYSTIMESTAMP`	`CURRENT_TIMESTAMP()`
`TO_DATE`	`PARSE_DATE`
`TO_TIMESTAMP`	`PARSE_TIMESTAMP`
`TO_TIMESTAMP_TZ`	`PARSE_TIMESTAMP`
`TZ_OFFSET`	Non è supportato in BigQuery. Valuta la possibilità di utilizzare una UDF personalizzata.
`WM_CONTAINS` `WM_EQUALS` `WM_GREATERTHAN` `WM_INTERSECTION` `WM_LDIFF` `WM_LESSTHAN` `WM_MEETS` `WM_OVERLAPS` `WM_RDIFF`	I periodi non vengono utilizzati in BigQuery. Le funzioni definite dall'utente possono essere utilizzate per confrontare due periodi.

BigQuery offre le seguenti funzioni aggiuntive per data/ora:

Funzioni di stringa

La tabella seguente mostra le mappature tra le funzioni di stringa di Oracle e i relativi equivalenti di BigQuery:

Oracle	BigQuery
`ASCII`	`TO_CODE_POINTS(string_expr)[OFFSET(0)]`
`ASCIISTR`	BigQuery non supporta UTF-16
`RAWTOHEX`	`TO_HEX`
`LENGTH`	`CHAR_LENGTH`
`LENGTH`	`CHARACTER_LENGTH`
`CHR`	`CODE_POINTS_TO_STRING( [mod(numeric_expr, 256)] )`
`COLLATION`	Non esiste in BigQuery. BigQuery non supporta COLLATE in DML
`COMPOSE`	Funzione definita dall'utente personalizzata.
`CONCAT, (\|\| operator)`	`CONCAT`
`DECOMPOSE`	Funzione definita dall'utente personalizzata.
`ESCAPE_REFERENCE (UTL_I18N)`	Non è supportato in BigQuery. Valuta la possibilità di utilizzare una funzione definita dall'utente'utente.
`INITCAP`	`INITCAP`
`INSTR/INSTR2/INSTR4/INSTRB/INSTRC`	Funzione definita dall'utente personalizzata.
`LENGTH/LENGTH2/LENGTH4/LENGTHB/LENGTHC`	`LENGTH`
`LOWER`	`LOWER`
`LPAD`	`LPAD`
`LTRIM`	`LTRIM`
`NLS_INITCAP`	Funzione definita dall'utente personalizzata.
`NLS_LOWER`	`LOWER`
`NLS_UPPER`	`UPPER`
`NLSSORT`	Specifico di Oracle, non esiste in BigQuery.
`POSITION`	`STRPOS(string, substring)`
`PRINTBLOBTOCLOB`	Specifico di Oracle, non esiste in BigQuery.
`REGEXP_COUNT`	`ARRAY_LENGTH(REGEXP_EXTRACT_ALL(value, regex))`
`REGEXP_INSTR`	`STRPOS(source_string, REGEXP_EXTRACT(source_string, regexp_string))` Nota: restituisce la prima occorrenza.
`REGEXP_REPLACE`	`REGEXP_REPLACE`
`REGEXP_LIKE`	`IF(REGEXP_CONTAINS,1,0)`
`REGEXP_SUBSTR`	`REGEXP_EXTRACT, REGEXP_EXTRACT_ALL`
`REPLACE`	`REPLACE`
`REVERSE`	`REVERSE`
`RIGHT`	`SUBSTR(source_string, -1, length)`
`RPAD`	`RPAD`
`RTRIM`	`RTRIM`
`SOUNDEX`	Non è supportato in BigQuery. Valuta la possibilità di utilizzare una UDF personalizzata
`STRTOK`	`SPLIT(instring, delimiter)[ORDINAL(tokennum)]` `Note: The entire delimiter string argument is used as a single delimiter. The default delimiter is a comma.`
`SUBSTR/SUBSTRB/SUBSTRC/SUBSTR2/SUBSTR4`	`SUBSTR`
`TRANSLATE`	`REPLACE`
`TRANSLATE USING`	`REPLACE`
`TRIM`	`TRIM`
`UNISTR`	`CODE_POINTS_TO_STRING`
`UPPER`	`UPPER`
`\|\|` (BARRE VERTICALI)	`CONCAT`

BigQuery offre le seguenti funzioni di stringa aggiuntive:

Funzioni matematiche

La tabella seguente mostra le mappature tra le funzioni matematiche di Oracle e i relativi equivalenti di BigQuery.

Oracle	BigQuery
`ABS`	`ABS`
`ACOS`	`ACOS`
`ACOSH`	`ACOSH`
`ASIN`	`ASIN`
`ASINH`	`ASINH`
`ATAN`	`ATAN`
`ATAN2`	`ATAN2`
`ATANH`	`ATANH`
`CEIL`	`CEIL`
`CEILING`	`CEILING`
`COS`	`COS`
`COSH`	`COSH`
`EXP`	`EXP`
`FLOOR`	`FLOOR`
`GREATEST`	`GREATEST`
`LEAST`	`LEAST`
`LN`	`LN`
`LNNVL`	Utilizza con `ISNULL`
`LOG`	`LOG`
`MOD (% operator)`	`MOD`
`POWER (** operator)`	`POWER, POW`
`DBMS_RANDOM.VALUE`	`RAND`
`RANDOMBYTES`	Non è supportato in BigQuery. Valuta la possibilità di utilizzare una funzione UDF e RAND personalizzata
`RANDOMINTEGER`	`CAST(FLOOR(10*RAND()) AS INT64)`
`RANDOMNUMBER`	Non è supportato in BigQuery. Valuta la possibilità di utilizzare una funzione UDF e RAND personalizzata
`REMAINDER`	`MOD`
`ROUND`	`ROUND`
`ROUND_TIES_TO_EVEN`	`ROUND()`
`SIGN`	`SIGN`
`SIN`	`SIN`
`SINH`	`SINH`
`SQRT`	`SQRT`
`STANDARD_HASH`	`FARM_FINGERPRINT, MD5, SHA1, SHA256, SHA512`
`STDDEV`	STDDEV
`TAN`	`TAN`
`TANH`	`TANH`
`TRUNC`	`TRUNC`
`NVL`	`IFNULL(expr, 0), COALESCE(exp, 0)`

BigQuery offre le seguenti funzioni matematiche aggiuntive:

Funzioni di conversione del tipo

La tabella seguente mostra le mappature tra le funzioni di conversione del tipo Oracle e i relativi equivalenti BigQuery.

Oracle	BigQuery
`BIN_TO_NUM`	`SAFE_CONVERT_BYTES_TO_STRING(value)` `CAST(x AS INT64)`
`BINARY2VARCHAR`	`SAFE_CONVERT_BYTES_TO_STRING(value)`
`CAST CAST_FROM_BINARY_DOUBLE CAST_FROM_BINARY_FLOAT CAST_FROM_BINARY_INTEGER CAST_FROM_NUMBER CAST_TO_BINARY_DOUBLE CAST_TO_BINARY_FLOAT CAST_TO_BINARY_INTEGER CAST_TO_NUMBER CAST_TO_NVARCHAR2 CAST_TO_RAW >CAST_TO_VARCHAR`	`CAST(expr AS typename)`
`CHARTOROWID`	Non è necessaria una specifica Oracle.
`CONVERT`	BigQuery non supporta gli insiemi di caratteri. Valuta la possibilità di utilizzare funzione definita dall'utente dall'utente personalizzata.
`EMPTY_BLOB`	`BLOB` non viene utilizzato in BigQuery.
`EMPTY_CLOB`	`CLOB` non viene utilizzato in BigQuery.
`FROM_TZ`	I tipi con fusi orari non sono supportati in BigQuery. Valuta la possibilità di utilizzare una funzione definita dall'utente'utente e FORMAT_TIMESTAMP
`INT_TO_BOOL`	`CAST`
`IS_BIT_SET`	Non esiste implicitamente in BigQuery. Valuta la possibilità di utilizzare le funzioni definite dall'utente
`NCHR`	Le funzioni UDF possono essere utilizzate per ottenere l'equivalente in caratteri del binario
`NUMTODSINTERVAL`	Il tipo di dati `INTERVAL` non è supportato in BigQuery
`NUMTOHEX`	Non è supportato in BigQuery. Valuta la possibilità di utilizzare una funzione `TO_HEX` e una UDF personalizzata
`NUMTOHEX2`
`NUMTOYMINTERVAL`	Il tipo di dati `INTERVAL` non è supportato in BigQuery.
`RAW_TO_CHAR`	Specifico di Oracle, non esiste in BigQuery.
`RAW_TO_NCHAR`	Specifico di Oracle, non esiste in BigQuery.
`RAW_TO_VARCHAR2`	Specifico di Oracle, non esiste in BigQuery.
`RAWTOHEX`	Specifico di Oracle, non esiste in BigQuery.
`RAWTONHEX`	Specifico di Oracle, non esiste in BigQuery.
`RAWTONUM`	Specifico di Oracle, non esiste in BigQuery.
`RAWTONUM2`	Specifico di Oracle, non esiste in BigQuery.
`RAWTOREF`	Specifico di Oracle, non esiste in BigQuery.
`REFTOHEX`	Specifico di Oracle, non esiste in BigQuery.
`REFTORAW`	Specifico di Oracle, non esiste in BigQuery.
`ROWIDTOCHAR`	`ROWID` è un tipo specifico di Oracle e non esiste in BigQuery. Questo valore deve essere rappresentato come stringa.
`ROWIDTONCHAR`	`ROWID` è un tipo specifico di Oracle e non esiste in BigQuery. Questo valore deve essere rappresentato come stringa.
`SCN_TO_TIMESTAMP`	`SCN` è un tipo specifico di Oracle e non esiste in BigQuery. Questo valore deve essere rappresentato come timestamp.
`TO_ACLID TO_ANYLOB TO_APPROX_COUNT_DISTINCT TO_APPROX_PERCENTILE TO_BINARY_DOUBLE TO_BINARY_FLOAT TO_BLOB TO_CHAR TO_CLOB TO_DATE TO_DSINTERVAL TO_LOB TO_MULTI_BYTE TO_NCHAR TO_NCLOB TO_NUMBER TO_RAW TO_SINGLE_BYTE TO_TIME` TO_TIMESTAMP TO_TIMESTAMP_TZ TO_TIME_TZ TO_UTC_TIMEZONE_TZ TO_YMINTERVAL	`CAST(expr AS typename)` `PARSE_DATE` `PARSE_TIMESTAMP` La sintassi di conversione viene utilizzata in una query per indicare che il tipo di risultato di un'espressione deve essere convertito in un altro tipo.
`TREAT`	Specifico di Oracle, non esiste in BigQuery.
`VALIDATE_CONVERSION`	Non è supportato in BigQuery. Valuta la possibilità di utilizzare una UDF personalizzata
`VSIZE`	Non è supportato in BigQuery. Valuta la possibilità di utilizzare una UDF personalizzata

Funzioni JSON

La tabella seguente mostra le mappature tra le funzioni JSON di Oracle e i relativi equivalenti di BigQuery.

Oracle	BigQuery
`AS_JSON`	`TO_JSON_STRING(value[, pretty_print])`
`JSON_ARRAY`	Valuta la possibilità di utilizzare le funzioni definite dall'utente e la funzione `TO_JSON_STRING`
`JSON_ARRAYAGG`	Valuta la possibilità di utilizzare le funzioni definite dall'utente e la funzione `TO_JSON_STRING`
`JSON_DATAGUIDE`	Funzione definita dall'utente personalizzata.
`JSON_EQUAL`	Funzione definita dall'utente personalizzata.
`JSON_EXIST`	Valuta la possibilità di utilizzare le funzioni definite dall'utente e `JSON_EXTRACT` o `JSON_EXTRACT_SCALAR`
`JSON_MERGEPATCH`	Funzione definita dall'utente personalizzata.
`JSON_OBJECT`	Non è supportato da BigQuery.
`JSON_OBJECTAGG`	Non è supportato da BigQuery.
`JSON_QUERY`	Valuta la possibilità di utilizzare le funzioni definite dall'utente e `JSON_EXTRACT` o `JSON_EXTRACT_SCALAR`.
`JSON_TABLE`	Funzione definita dall'utente personalizzata.
`JSON_TEXTCONTAINS`	Valuta la possibilità di utilizzare le funzioni definite dall'utente e `JSON_EXTRACT` o `JSON_EXTRACT_SCALAR`.
`JSON_VALUE`	`JSON_EXTRACT_SCALAR`

Funzioni XML

BigQuery non fornisce funzioni XML implicite. I dati XML possono essere caricati in BigQuery come stringa e le funzioni definite dall'utente possono essere utilizzate per analizzare i dati XML. In alternativa, l'elaborazione XML può essere eseguita da uno strumento ETL/ELT come Dataflow. L'elenco seguente mostra le funzioni XML di Oracle:

Oracle	BigQuery
`DELETEXML`	Per l'elaborazione di XML puoi utilizzare le UDF di BigQuery o uno strumento ETL come Dataflow.
`ENCODE_SQL_XML`
`EXISTSNODE`
`EXTRACTCLOBXML`
`EXTRACTVALUE`
`INSERTCHILDXML`
`INSERTCHILDXMLAFTER`
`INSERTCHILDXMLBEFORE`
`INSERTXMLAFTER`
`INSERTXMLBEFORE`
`SYS_XMLAGG`
`SYS_XMLANALYZE`
`SYS_XMLCONTAINS`
`SYS_XMLCONV`
`SYS_XMLEXNSURI`
`SYS_XMLGEN`
`SYS_XMLI_LOC_ISNODE`
`SYS_XMLI_LOC_ISTEXT`
`SYS_XMLINSTR`
`SYS_XMLLOCATOR_GETSVAL`
`SYS_XMLNODEID`
`SYS_XMLNODEID_GETLOCATOR`
`SYS_XMLNODEID_GETOKEY`
`SYS_XMLNODEID_GETPATHID`
`SYS_XMLNODEID_GETPTRID`
`SYS_XMLNODEID_GETRID`
`SYS_XMLNODEID_GETSVAL`
`SYS_XMLT_2_SC`
`SYS_XMLTRANSLATE`
`SYS_XMLTYPE2SQL`
`UPDATEXML`
`XML2OBJECT`
`XMLCAST`
`XMLCDATA`
`XMLCOLLATVAL`
`XMLCOMMENT`
`XMLCONCAT`
`XMLDIFF`
`XMLELEMENT`
`XMLEXISTS`
`XMLEXISTS2`
`XMLFOREST`
`XMLISNODE`
`XMLISVALID`
`XMLPARSE`
`XMLPATCH`
`XMLPI`
`XMLQUERY`
`XMLQUERYVAL`
`XMLSERIALIZE`
`XMLTABLE`
`XMLTOJSON`
`XMLTRANSFORM`
`XMLTRANSFORMBLOB`
`XMLTYPE`

Funzioni di machine learning

Le funzioni di machine learning (ML) in Oracle e BigQuery sono diverse. Oracle richiede licenze e pacchetti di analisi avanzate per eseguire il machine learning nel database. Oracle utilizza il pacchetto DBMS_DATA_MINING per l'apprendimento automatico. La conversione dei job di data mining di Oracle richiede la riscrittura del codice. Puoi scegliere tra le offerte di prodotti di IA di Google, come BigQuery ML, API di IA (tra cui Speech-to-Text, Text-to-Speech, Dialogflow, Cloud Translation, NLP, Cloud Vision e API Timeseries Insights, AutoML, AutoML Tables o AI Platform. I notebook gestiti dall'utente di Google possono essere utilizzati come ambiente di sviluppo per i data scientist e AI Platform Training di Google può essere utilizzato per eseguire su larga scala i carichi di lavoro di addestramento e di calcolo del punteggio. La tabella seguente mostra le funzioni di ML di Oracle:

Oracle	BigQuery
`CLASSIFIER`	Consulta BigQuery ML per le opzioni di classificazione e regressione del machine learning
`CLUSTER_DETAILS`
`CLUSTER_DISTANCE`
`CLUSTER_ID`
`CLUSTER_PROBABILITY`
`CLUSTER_SET`
`PREDICTION`
`PREDICTION_BOUNDS`
`PREDICTION_COST`
`PREDICTION_DETAILS`
`PREDICTION_PROBABILITY`
`PREDICTION_SET`

Funzioni di sicurezza

La tabella seguente mostra le funzioni per identificare l'utente in Oracle e BigQuery:

Oracle	BigQuery
`UID`	`SESSION_USER`
`USER/SESSION_USER/CURRENT_USER`	`SESSION_USER()`

Funzioni di set o array

La tabella seguente mostra le funzioni di set o array in Oracle e i relativi equivalenti in BigQuery:

Oracle	BigQuery
`MULTISET`	`ARRAY_AGG`
`MULTISET EXCEPT`	`ARRAY_AGG([DISTINCT] expression)`
`MULTISET INTERSECT`	`ARRAY_AGG([DISTINCT])`
`MULTISET UNION`	`ARRAY_AGG`

Funzioni finestra

La tabella seguente mostra le funzioni finestra in Oracle e i relativi equivalenti in BigQuery.

Oracle	BigQuery
`LAG`	`LAG (value_expression[, offset [, default_expression]])`
`LEAD`	`LEAD (value_expression[, offset [, default_expression]])`

Query gerarchiche o ricorsive

Le query gerarchiche o ricorsive non vengono utilizzate in BigQuery. Se la profondità della gerarchia è nota, è possibile ottenere funzionalità simili con le unioni, come illustrato nell'esempio seguente. Un'altra soluzione consiste nell'utilizzare l'API BigQueryStorage e Spark.

select
  array(
    select e.update.element
    union all
    select c1 from e.update.element.child as c1
    union all
    select c2 from e.update.element.child as c1, c1.child as c2
    union all
    select c3 from e.update.element.child as c1, c1.child as c2, c2.child as c3
    union all
    select c4 from e.update.element.child as c1, c1.child as c2, c2.child as c3, c3.child as c4
    union all
    select c5 from e.update.element.child as c1, c1.child as c2, c2.child as c3, c3.child as c4, c4.child as c5
  ) as flattened,
  e as event
from t, t.events as e

La tabella seguente mostra le funzioni gerarchiche in Oracle.

Oracle	BigQuery
`DEPTH`	Le query gerarchiche non vengono utilizzate in BigQuery.
`PATH`
`SYS_CONNECT_BY_PATH (hierarchical)`

Funzioni UTL

UTL_File Il pacchetto viene utilizzato principalmente per leggere e scrivere i file del sistema operativo da PL/SQL. Cloud Storage può essere utilizzato per qualsiasi tipo di gestione temporanea dei file non elaborati. Le tabelle esterne e i comandi BigQuery load ed export devono essere utilizzati per leggere e scrivere file da e verso Cloud Storage. Per maggiori informazioni, consulta Introduzione alle origini dati esterne.

Funzioni spaziali

Puoi utilizzare le analisi geospaziali di BigQuery per sostituire la funzionalità spaziale. In Oracle esistono funzioni e tipi SDO_* come SDO_GEOM_KEY, SDO_GEOM_MBR, SDO_GEOM_MMB. Queste funzioni vengono utilizzate per l'analisi spaziale. Puoi utilizzare le analisi geospaziali per eseguire analisi spaziali.

Sintassi DML

Questa sezione illustra le differenze nella sintassi del linguaggio di gestione dei dati tra Oracle e BigQuery.

`INSERT` dichiarazione

La maggior parte delle istruzioni INSERT di Oracle è compatibile con BigQuery. La tabella seguente mostra le eccezioni.

Gli script DML in BigQuery hanno una semantica di coerenza leggermente diversa rispetto alle istruzioni equivalenti in Oracle. Per una panoramica dell'isolamento degli snapshot e della gestione delle sessioni e delle transazioni, consulta CREATE [UNIQUE] INDEX section in un altro punto di questo documento.

Oracle BigQuery

Oracle	BigQuery
`INSERT INTO table VALUES (...);`	`INSERT INTO table (...) VALUES (...);` Oracle offre una parola chiave `DEFAULT` per le colonne non null. Nota: in BigQuery, l'omissione dei nomi delle colonne nell'istruzione `INSERT` funziona solo se i valori di tutte le colonne della tabella di destinazione sono inclusi in ordine crescente in base alle relative posizioni ordinali.
`INSERT INTO table VALUES (1,2,3); INSERT INTO table VALUES (4,5,6); INSERT INTO table VALUES (7,8,9); INSERT ALL INTO table (col1, col2) VALUES ('val1_1', 'val1_2') INTO table (col1, col2) VALUES ('val2_1', 'val2_2') INTO table (col1, col2) VALUES ('val3_1', 'val3_2') . . . SELECT 1 FROM DUAL;`	`INSERT INTO table VALUES (1,2,3), (4,5,6), (7,8,9);` BigQuery impone quote DML, che limitano il numero di istruzioni DML che puoi eseguire ogni giorno. Per sfruttare al meglio la quota, valuta i seguenti approcci: Combina più righe in un'unica istruzione `INSERT` anziché una riga per operazione `INSERT`. Combina più istruzioni DML (incluse `INSERT`) utilizzando un'istruzione `MERGE`. Usa `CREATE TABLE ... AS SELECT` per creare e compilare nuove tabelle.

INSERT INTO table VALUES (...);

INSERT INTO table (...) VALUES (...);

Oracle offre una parola chiave DEFAULT per le colonne non null.

Nota: in BigQuery, l'omissione dei nomi delle colonne nell'istruzione INSERT funziona solo se i valori di tutte le colonne della tabella di destinazione sono inclusi in ordine crescente in base alle relative posizioni ordinali.

INSERT INTO table VALUES (1,2,3);

    INSERT INTO table VALUES (4,5,6);

    INSERT INTO table VALUES (7,8,9);

    INSERT ALL

    INTO table (col1, col2) VALUES ('val1_1', 'val1_2')

    INTO table (col1, col2) VALUES ('val2_1', 'val2_2')

    INTO table (col1, col2) VALUES ('val3_1', 'val3_2')

    .

    .

    .

    SELECT 1 FROM DUAL;

INSERT INTO table VALUES (1,2,3),
(4,5,6),
(7,8,9);

BigQuery impone quote DML, che limitano il numero di istruzioni DML che puoi eseguire ogni giorno. Per sfruttare al meglio la quota, valuta i seguenti approcci:

Combina più righe in un'unica istruzione INSERT anziché una riga per operazione INSERT.
Combina più istruzioni DML (incluse INSERT) utilizzando un'istruzione MERGE.
Usa CREATE TABLE ... AS SELECT per creare e compilare nuove tabelle.

`UPDATE` dichiarazione

Le istruzioni UPDATE di Oracle sono per lo più compatibili con BigQuery, tuttavia, in BigQuery l'istruzione UPDATE deve avere una clausola WHERE.

Come best practice, ti consigliamo di preferire le istruzioni DML batch a più istruzioni singoleUPDATE e INSERT. Gli script DML in BigQuery hanno una semantica di coerenza leggermente diversa rispetto alle istruzioni equivalenti in Oracle. Per una panoramica sull'isolamento degli snapshot e sulla gestione di sessioni e transazioni, consulta la sezione CREATE INDEX di questo documento.

La tabella seguente mostra le istruzioni UPDATE di Oracle e le istruzioni BigQuery che svolgono le stesse attività.

In BigQuery l'istruzione UPDATE deve avere una clausola WHERE. Per ulteriori informazioni su UPDATE in BigQuery, consulta gli esempi di UPDATE di BigQuery nella documentazione DML.

Estratti conto `DELETE` e `TRUNCATE`

Le istruzioni DELETE e TRUNCATE sono entrambi modi per rimuovere righe da una tabella senza influire sullo schema della tabella. TRUNCATE non viene utilizzato in BigQuery. Tuttavia, puoi utilizzare le istruzioni DELETE per ottenere lo stesso effetto.

In BigQuery, l'istruzione DELETE deve avere una clausola WHERE. Per ulteriori informazioni su DELETE in BigQuery, consulta gli esempi di DELETE di BigQuery nella documentazione DML.

Oracle	BigQuery
`DELETE database.table;`	`DELETE FROM table WHERE TRUE;`

`MERGE` dichiarazione

L'istruzione MERGE può combinare le operazioni INSERT, UPDATE e DELETE in un'unica istruzione UPSERT ed eseguire le operazioni in modo atomico. L'operazione MERGE deve corrispondere a un massimo di una riga di origine per ogni riga di destinazione. BigQuery e Oracle utilizzano entrambi la sintassi ANSI.

Tuttavia, gli script DML in BigQuery hanno una semantica di coerenza leggermente diversa rispetto alle istruzioni equivalenti in Oracle.

Sintassi DDL

Questa sezione illustra le differenze nella sintassi del linguaggio di definizione dei dati tra Oracle e BigQuery.

`CREATE TABLE` dichiarazione

La maggior parte delle istruzioni CREATE TABLE di Oracle è compatibile con BigQuery, ad eccezione dei seguenti vincoli ed elementi di sintassi, che non vengono utilizzati in BigQuery:

STORAGE
TABLESPACE
DEFAULT
GENERATED ALWAYS AS
ENCRYPT
PRIMARY KEY (col, ...). Per ulteriori informazioni, consulta CREATE INDEX.
UNIQUE INDEX. Per ulteriori informazioni, consulta CREATE INDEX.
CONSTRAINT..REFERENCES
DEFAULT
PARALLEL
COMPRESS

Per ulteriori informazioni su CREATE TABLE in BigQuery, consulta gli esempi di CREATE TABLE di BigQuery.

Opzioni e attributi delle colonne

Le colonne di identità vengono introdotte con la versione Oracle 12c che consente l'incremento automatico di una colonna. Questo non viene utilizzato in BigQuery, ma può essere ottenuto con il seguente metodo batch. Per ulteriori informazioni sulle chiavi surrogate e sulle dimensioni con variazioni lente (SCD), consulta le seguenti guide:

Oracle	BigQuery
`CREATE TABLE table ( id NUMBER GENERATED ALWAYS AS IDENTITY, description VARCHAR2(30) );`	`INSERT INTO dataset.table SELECT *, ROW_NUMBER() OVER () AS id FROM dataset.table`

Commenti sulle colonne

Oracle utilizza la sintassi Comment per aggiungere commenti alle colonne. Questa funzionalità può essere implementata in modo simile in BigQuery utilizzando la descrizione della colonna come mostrato nella tabella seguente:

Oracle	BigQuery
`Comment on column table is 'column desc';`	`CREATE TABLE dataset.table ( col1 STRING OPTIONS(description="column desc") );`

Tabelle temporanee

Oracle supporta le tabelle temporanee, che vengono spesso utilizzate per archiviare i risultati intermedi negli script. Le tabelle temporanee sono supportate in BigQuery.

Oracle	BigQuery
`CREATE GLOBAL TEMPORARY TABLE temp_tab (x INTEGER, y VARCHAR2(50)) ON COMMIT DELETE ROWS; COMMIT;`	`CREATE TEMP TABLE temp_tab ( x INT64, y STRING ); DELETE FROM temp_tab WHERE TRUE;`

I seguenti elementi Oracle non vengono utilizzati in BigQuery:

ON COMMIT DELETE ROWS;
ON COMMIT PRESERVE ROWS;

Esistono anche altri modi per emulare le tabelle temporanee in BigQuery:

TTL del set di dati:crea un set di dati con un TTL breve (ad esempio un'ora) in modo che tutte le tabelle create nel set di dati siano effettivamente temporanee (poiché non rimarranno più a lungo del TTL del set di dati). Puoi premettere a tutti i nomi delle tabelle in questo set di dati il prefisso temp per indicare chiaramente che le tabelle sono temporanee.

TTL tabella:crea una tabella con un TTL breve specifico della tabella utilizzando istruzioni DDL simili alla seguente:

CREATE TABLE temp.name (col1, col2, ...)

OPTIONS(expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 1 HOUR));

Clausola WITH: se una tabella temporanea è necessaria solo all'interno dello stesso blocco, utilizza un risultato temporaneo con un'istruzione o una sottoquery WITH.

`CREATE SEQUENCE` dichiarazione

Le sequenze non vengono utilizzate in BigQuery, ma è possibile ottenere lo stesso risultato con il seguente metodo batch. Per ulteriori informazioni sulle chiavi surrogate e sulle dimensioni con variazioni lente (SCD), consulta le seguenti guide:

INSERT INTO dataset.table
    SELECT *,
      ROW_NUMBER() OVER () AS id
      FROM dataset.table

`CREATE VIEW` dichiarazione

La tabella seguente mostra gli equivalenti tra Oracle e BigQuery per l'istruzione CREATE VIEW.

Oracle	BigQuery	Note
`CREATE VIEW view_name AS SELECT ...`	`CREATE VIEW view_name AS SELECT ...`
`CREATE OR REPLACE VIEW view_name AS SELECT ...`	`CREATE OR REPLACE VIEW` `view_name AS` `SELECT ...`
Non supportata	`CREATE VIEW IF NOT EXISTS` `view_name` `OPTIONS(view_option_list)` `AS SELECT ...`	Crea una nuova vista solo se non esiste attualmente nel set di dati specificato.

`CREATE MATERIALIZED VIEW` dichiarazione

In BigQuery, le operazioni di aggiornamento delle vista materializzata vengono eseguite automaticamente. Non è necessario specificare le opzioni di aggiornamento (ad esempio al commit o in base alla pianificazione) in BigQuery. Per ulteriori informazioni, consulta Introduzione alle viste tabelle materializzate.

Se la tabella di base continua a cambiare solo tramite aggiunte, la query che utilizza la vista materializzata (indipendentemente dal fatto che la vista sia esplicitamente richiamata o selezionata dall'ottimizzatore delle query) esegue la scansione di tutte le viste materializzate più un delta nella tabella di base dall'ultimo aggiornamento della vista. Ciò significa che le query sono più rapide e meno costose.

Al contrario, se sono stati apportati aggiornamenti (DML UPDATE / MERGE) o eliminazioni (DML DELETE, troncamento, scadenza della partizione) nella tabella di base dall'ultimo aggiornamento della vista, le vista materializzata non vengono sottoposte a scansione e quindi le query non ottengono alcun risparmio fino al successivo aggiornamento della vista. In sostanza, qualsiasi aggiornamento o eliminazione nella tabella di base invalida lo stato della vista materializzata.

Inoltre, i dati del buffer di streaming della tabella di base non vengono salvati nella vista materializzata. Il buffer di streaming viene comunque sottoposto a scansione completa, indipendentemente dall'utilizzo o meno della vista materializzata.

La tabella seguente mostra gli equivalenti tra Oracle e BigQuery per l'istruzione CREATE MATERIALIZED VIEW.

Oracle	BigQuery	Note
`CREATE MATERIALIZED VIEW view_name REFRESH FAST NEXT sysdate + 7 AS SELECT … FROM TABLE_1`	`CREATE MATERIALIZED VIEW view_name AS SELECT ...`

`CREATE [UNIQUE] INDEX` dichiarazione

Questa sezione descrive gli approcci in BigQuery per creare funzionalità simili agli indici in Oracle.

Indicizzazione per il rendimento

BigQuery non ha bisogno di indici espliciti, in quanto è un database colonnare con ottimizzazione di query e archiviazione. BigQuery fornisce funzionalità come partizionamento e clustering, nonché campi nidificati, che possono aumentare l'efficienza e le prestazioni delle query ottimizzando la modalità di archiviazione dei dati.

Indicizzazione per coerenza (UNIQUE, PRIMARY INDEX)

In Oracle, è possibile utilizzare un indice univoco per impedire righe con chiavi non univoche in una tabella. Se un processo tenta di inserire o aggiornare dati con un valore già presente nell'indice, l'operazione non va a buon fine a causa di una violazione dell'indice.

Poiché BigQuery non fornisce indici espliciti, è possibile utilizzare un'istruzione MERGE per inserire solo record univoci in una tabella di destinazione da una tabella intermedia, ignorando contemporaneamente i record duplicati. Tuttavia, non è possibile impedire a un utente con autorizzazioni di modifica di inserire un record duplicato.

Per generare un errore per i record duplicati in BigQuery, puoi utilizzare un'istruzione MERGE dalla tabella di staging, come mostrato nell'esempio seguente:

Oracle		BigQuery
`CREATE [UNIQUE] INDEX name;`		MERGE `prototype.FIN_MERGE` t \ USING `prototype.FIN_TEMP_IMPORT` m \ ON t.col1 = m.col1 \ AND t.col2 = m.col2 \ WHEN MATCHED THEN \ UPDATE SET t.col1 = ERROR(CONCAT('Encountered Error for ', m.col1, ' ', m.col2)) \ WHEN NOT MATCHED THEN \ INSERT (col1,col2,col3,col4,col5,col6,col7,col8) VALUES(col1,col2,col3,col4,col5,col6, CURRENT_TIMESTAMP(),CURRENT_TIMESTAMP());

Più spesso, gli utenti preferiscono rimuovere i duplicati in modo indipendente per trovare errori nei sistemi a valle.

BigQuery non supporta le colonne DEFAULT e IDENTITY (sequenze).

Chiusura della serratura

BigQuery non dispone di un meccanismo di blocco come Oracle e può eseguire query contemporaneamente (fino alla tua quota). Solo le istruzioni DML hanno determinati limiti di concorrenza e in alcuni scenari potrebbero richiedere un blocco della tabella durante l'esecuzione.

Istruzioni SQL procedurali

Questa sezione descrive come convertire le istruzioni SQL procedurali utilizzate in stored procedure, funzioni e trigger da Oracle a BigQuery.

`CREATE PROCEDURE` dichiarazione

Le stored procedure sono supportate nell'ambito di BigQuery Scripting Beta.

Oracle	BigQuery	Note
`CREATE PROCEDURE`	`CREATE PROCEDURE`	Come Oracle, BigQuery supporta le modalità degli argomenti `IN, OUT, INOUT`. Altre specifiche di sintassi non sono supportate in BigQuery.
`CREATE OR REPLACE PROCEDURE`	`CREATE OR REPLACE PROCEDURE`
`CALL`	`CALL`

Le sezioni seguenti descrivono i modi per convertire le istruzioni procedurali Oracle esistenti in istruzioni di scripting BigQuery con funzionalità simili.

`CREATE TRIGGER` dichiarazione

Gli attivatori non vengono utilizzati in BigQuery. La logica dell'applicazione basata su riga deve essere gestita a livello di applicazione. La funzionalità di attivazione può essere ottenuta utilizzando lo strumento di importazione, le funzioni Pub/Sub e/o Cloud Run durante il momento di importazione o utilizzando scansioni regolari.

Dichiarazione e assegnazione di variabili

La tabella seguente mostra le istruzioni DECLAREdi Oracle e i relativi equivalenti BigQuery.

Oracle	BigQuery
`DECLARE L_VAR NUMBER; BEGIN L_VAR := 10 + 20; END;`	`DECLARE L_VAR int64; BEGIN SET L_VAR = 10 + 20; SELECT L_VAR; END`
`SET var = value;`	`SET var = value;`

Dichiarazioni e operazioni del cursore

BigQuery non supporta i cursori, pertanto le seguenti istruzioni non vengono utilizzate in BigQuery:

DECLARE cursor_name CURSOR [FOR | WITH] ...
OPEN CUR_VAR FOR sql_str;
OPEN cursor_name [USING var, ...];
FETCH cursor_name INTO var, ...;
CLOSE cursor_name;

Istruzioni SQL dinamiche

La seguente istruzione SQL dinamica di Oracle e il relativo equivalente BigQuery:

Oracle	BigQuery
`EXECUTE IMMEDIATE sql_str [USING IN OUT [, ...]];`	`EXECUTE IMMEDIATE sql_expression [INTO variable[, ...]] [USING identifier[, ...]]; ;`

Istruzioni di controllo del flusso

La tabella seguente mostra le istruzioni di controllo del flusso di Oracle e i relativi equivalenti di BigQuery.

Oracle	BigQuery
`IF condition THEN [if_statement_list] [ELSE else_statement_list ] END IF;`	`IF condition THEN [if_statement_list] [ELSE else_statement_list ] END IF;`
`SET SERVEROUTPUT ON; DECLARE x INTEGER DEFAULT 0; y INTEGER DEFAULT 0; BEGIN LOOP IF x>= 10 THEN EXIT; ELSIF x>= 5 THEN y := 5; END IF; x := x + 1; END LOOP; dbms_output.put_line(x\|\|','\|\|y); END; /`	`DECLARE x INT64 DEFAULT 0; DECLARE y INT64 DEFAULT 0; LOOP IF x>= 10 THEN LEAVE; ELSE IF x>= 5 THEN SET y = 5; END IF; END IF; SET x = x + 1; END LOOP; SELECT x,y;`
`LOOP sql_statement_list END LOOP;`	`LOOP sql_statement_list END LOOP;`
`WHILE boolean_expression DO sql_statement_list END WHILE;`	`WHILE boolean_expression DO sql_statement_list END WHILE;`
`FOR LOOP`	`FOR LOOP` non viene utilizzato in BigQuery. Utilizza altre istruzioni `LOOP`.
`BREAK`	`BREAK`
`CONTINUE`	`CONTINUE`
`CONTINUE/EXIT WHEN`	Utilizza `CONTINUE` con la condizione `IF`.
`GOTO`	L'istruzione `GOTO` non esiste in BigQuery. Utilizza la condizione `IF`.

Istruzioni SQL per metadati e transazioni

Oracle	BigQuery
`GATHER_STATS_JOB`	Non ancora utilizzato in BigQuery.
`LOCK TABLE table_name IN [SHARE/EXCLUSIVE] MODE NOWAIT;`	Non ancora utilizzato in BigQuery.
`Alter session set isolation_level=serializable; /` `SET TRANSACTION ...`	BigQuery utilizza sempre l'isolamento degli snapshot. Per maggiori dettagli, consulta la sezione Garanzia della coerenza e isolamento delle transazioni in questo documento.
`EXPLAIN PLAN ...`	Non utilizzato in BigQuery. Funzionalità simili sono la spiegazione del piano di query nell'interfaccia utente web di BigQuery e l'allocazione degli slot, nonché il logging di controllo in Stackdriver.
`SELECT * FROM DBA_[*];` (visualizzazioni DBA_/ALL_/V$ di Oracle)	`SELECT * FROM mydataset.INFORMATION_SCHEMA.TABLES;` Per ulteriori informazioni, consulta Introduzione a BigQuery INFORMATION_SCHEMA.
`SELECT * FROM GV$SESSION;` `SELECT * FROM V$ACTIVE_SESSION_HISTORY;`	BigQuery non ha il concetto di sessione tradizionale. Puoi visualizzare i job di query nell'interfaccia utente o esportare i log di controllo di Stackdriver in BigQuery e analizzare i log di BigQuery per analizzare i job. Per saperne di più, vedi Visualizzare i dettagli dei job.
`START TRANSACTION;` `LOCK TABLE table_A IN EXCLUSIVE MODE NOWAIT;` `DELETE FROM table_A;` `INSERT INTO table_A SELECT * FROM table_B;` `COMMIT;`	La sostituzione dei contenuti di una tabella con l'output della query è l'equivalente di una transazione. Puoi farlo con un'operazione di query o di copia. Utilizzo di una query: `bq query --replace --destination_table table_A 'SELECT * FROM table_B';` Utilizzo di una copia: `bq cp -f table_A table_B`

Istruzioni SQL con più istruzioni e su più righe

Sia Oracle che BigQuery supportano le transazioni (sessioni) e quindi supportano le istruzioni separate da punti e virgola che vengono eseguite insieme in modo coerente. Per ulteriori informazioni, consulta la sezione Transazioni con più istruzioni.

Messaggi e codici di errore

I codici di errore Oracle e i codici di errore BigQuery sono diversi. Se la logica dell'applicazione sta attualmente rilevando gli errori, prova a eliminare la fonte dell'errore, perché BigQuery non restituisce gli stessi codici di errore.

Garanzie di coerenza e isolamento delle transazioni

Sia Oracle che BigQuery sono atomici, ovvero conformi ad ACID a livello di mutazione su molte righe. Ad esempio, un'operazione MERGE è atomica, anche con più valori inseriti e aggiornati.

Transazioni

Oracle fornisce livelli di isolamento delle transazioni di tipo read committed o serializzabili. Sono possibili deadlock. I job di accodamento di insert di Oracle vengono eseguiti in modo indipendente.

BigQuery supporta inoltre le transazioni. BigQuery contribuisce a garantire il controllo della concorrenza ottimistico (chi esegue prima il commit vince) con l'isolamento degli snapshot, in cui una query legge gli ultimi dati sottoposti a commit prima dell'inizio della query. Questo approccio garantisce lo stesso livello di coerenza su base per riga, per mutazione e tra righe all'interno della stessa istruzione DML, evitando al contempo i deadlock. Nel caso di più istruzioni UPDATE per la stessa tabella, BigQuery passa al controllo della concorrenza pessimistico e accoda più istruzioni UPDATE, riprova automaticamente in caso di conflitti. Le istruzioni DML e i job di caricamento INSERT possono essere eseguiti contemporaneamente e in modo indipendente per accodare dati alle tabelle.

Esegui il rollback

Oracle supporta i rollback. Poiché in BigQuery non esiste un confine di transazione esplicito, non esiste il concetto di rollback esplicito in BigQuery. I metodi alternativi sono i decorator per tabelle o l'utilizzo di FOR SYSTEM_TIME AS OF.

Limiti per i database

Consulta le quote e i limiti più recenti di BigQuery. Molte quote per gli utenti con volumi elevati possono essere aumentate contattando l'assistenza clienti Google Cloud. La tabella seguente mostra un confronto dei limiti dei database Oracle e BigQuery.

Limite	Oracle	BigQuery
Tabelle per database	Senza restrizioni	Senza restrizioni
Colonne per tabella	1000	10.000
Dimensioni massime delle righe	Illimitato (dipende dal tipo di colonna)	100 MB
Lunghezza del nome delle colonne e delle tabelle	Se v12.2>= 128 byte Altrimenti 30 byte	16.384 caratteri Unicode
Righe per tabella	Illimitato	Illimitato
Lunghezza massima della richiesta SQL	Illimitato	1 MB (lunghezza massima delle query GoogleSQL non risolte) 12 MB (dimensione massima delle query in SQL precedente e GoogleSQL risolte) Streaming: 10 MB (limite di dimensione della richiesta HTTP) 10.000 (righe massime per richiesta)
Dimensioni massime di richieste e risposte	Illimitato	10 MB (richiesta) e 10 GB (risposta) oppure praticamente illimitato se utilizzi la paginazione o l'API Cloud Storage.
Numero massimo di sessioni simultanee	Limitato dai parametri delle sessioni o dei processi	100 query simultanee (possono essere aumentate con la prenotazione di slot), 300 richieste API simultanee per utente.
Numero massimo di caricamenti (rapidi) simultanei	Limitato dai parametri delle sessioni o dei processi	Nessun limite di concorrenza; i job vengono messi in coda. 100.000 job di caricamento per progetto al giorno.

Altri limiti di Oracle Database includono limiti dei tipi di dati, limiti dei database fisici, limiti dei database logici e limiti di processo e di runtime.