Questa pagina è stata tradotta dall'API Cloud Translation.

Guida alla traduzione SQL di Oracle

Questo documento descrive in dettaglio le analogie e le differenze nella sintassi SQL tra Oracle e BigQuery per aiutarti a pianificare la migrazione. Utilizza la traduzione SQL batch per migrare gli script SQL in blocco oppure la traduzione SQL interattiva per tradurre query ad hoc.

Tipi di dati

Questa sezione mostra le equivalenze 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 agli utenti di specificare valori personalizzati per la precisione o la scala. Di conseguenza, una colonna in Oracle potrebbe 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 ha più cifre dopo il separatore decimale di quelle specificate per la colonna corrispondente. In BigQuery questa funzionalità può essere implementata utilizzando la funzione `ROUND()`.
`NUMBER(*, x)`	`NUMERIC`	BigQuery non consente agli utenti di specificare valori personalizzati per la precisione o la scala. Di conseguenza, una colonna in Oracle potrebbe 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 ha più cifre dopo il separatore decimale di quelle specificate per la colonna corrispondente. In BigQuery questa funzionalità può essere implementata utilizzando la funzione `ROUND()`.
`NUMBER(x, -y)`	`INT64`	Se un utente tenta di memorizzare un numero decimale, Oracle lo arrotonda 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 BigQuery `INT64` consentono fino a 18 cifre di precisione. Se un campo numerico ha 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 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 BigQuery `INT64` consentono fino a 18 cifre di precisione. Se un campo numerico ha 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 corrispondere meglio al 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 corrispondere meglio al 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 corrispondere meglio al 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 sarebbe quello di 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 nell'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 la precisione in microsecondi (10^-6) rispetto a Oracle, che supporta una precisione compresa tra 0 e 9. BigQuery supporta un nome di regione del fuso orario di un database TZ e l'offset del fuso orario rispetto a UTC. In BigQuery, la conversione del fuso orario deve essere eseguita manualmente per corrispondere alla funzionalità `TIMESTAMP WITH LOCAL TIME ZONE` di Oracle.
`TIMESTAMP(x)`	`TIMESTAMP`	BigQuery supporta la precisione in microsecondi (10^-6) rispetto a Oracle, che supporta una precisione compresa tra 0 e 9. BigQuery supporta un nome di regione del fuso orario di un database TZ e l'offset del fuso orario rispetto a UTC. In BigQuery, la conversione del fuso orario deve essere eseguita manualmente per corrispondere alla funzionalità `TIMESTAMP WITH LOCAL TIME ZONE` di Oracle.
`TIMESTAMP WITH TIME ZONE`	`TIMESTAMP`	BigQuery supporta la precisione in microsecondi (10^-6) rispetto a Oracle, che supporta una precisione compresa tra 0 e 9. BigQuery supporta un nome di regione del fuso orario di un database TZ e l'offset del fuso orario rispetto a UTC. In BigQuery, la conversione del fuso orario deve essere eseguita manualmente per corrispondere alla funzionalità `TIMESTAMP WITH LOCAL TIME ZONE` di Oracle.
`TIMESTAMP WITH LOCAL TIME ZONE`	`TIMESTAMP`	BigQuery supporta la precisione in microsecondi (10^-6) rispetto a Oracle, che supporta una precisione compresa tra 0 e 9. BigQuery supporta un nome di regione del fuso orario di un database TZ e l'offset del fuso orario rispetto a UTC. In BigQuery, la conversione del fuso orario deve essere eseguita manualmente per corrispondere alla funzionalità `TIMESTAMP WITH LOCAL TIME ZONE` di Oracle.
`INTERVAL YEAR TO MONTH`	`STRING`	I valori di intervallo possono essere archiviati come tipo di dati `STRING` in BigQuery.
`INTERVAL DAY TO SECOND`	`STRING`	I valori di 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 nell'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 nell'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, i campi `ROWID` o `UROWID` non devono essere utilizzati nelle applicazioni. In questo caso, è possibile utilizzare il tipo di dati `STRING` per memorizzare questi dati.

Formattazione del tipo

Oracle SQL utilizza un insieme di formati predefiniti impostati come parametri per la visualizzazione di espressioni e dati delle colonne 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 vuoi, se hai file CSV con dati codificati nel formato ISO-8859-1, puoi specificare esplicitamente la codifica quando importi i dati in modo che BigQuery possa convertirli correttamente in UTF-8 durante il processo 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 previsto possono essere impostati nelle funzioni DATE e TIMESTAMP.

Formattazione del tipo di timestamp e data

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

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

Oracle	BigQuery	Note
`CURRENT_TIMESTAMP`	Le informazioni `TIMESTAMP` in Oracle possono avere informazioni sul fuso orario diverse, definite utilizzando `WITH TIME ZONE` nella definizione o nell'impostazione della colonna della variabile `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. (Internamente, BigQuery non ha un fuso orario.) 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 BigQuery e nella console BigQuery, `DATETIME` viene formattato utilizzando un separatore `T` in conformità con 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 il cast esplicito di una stringa. Ad esempio, la seguente espressione restituisce sempre uno spazio come separatore: `CAST(CURRENT_DATETIME() AS STRING)`
`CURRENT_DATE SYSDATE`	Oracle utilizza due tipi per la data: tipo 12 type 13 Oracle utilizza il tipo 12 per archiviare le date. Internamente, questi sono numeri a lunghezza fissa. Oracle utilizza il tipo 13 quando viene restituito da `SYSDATE or CURRENT_DATE`	BigQuery ha un formato `DATE` separato che restituisce sempre una data nel formato ISO 8601. `DATE_FROM_UNIX_DATE` non può essere utilizzato perché è basato sul 1970.
`CURRENT_DATE-3`	I valori di data sono rappresentati come numeri interi. Oracle supporta gli operatori aritmetici per i tipi di dati di data.	Per i tipi di data, 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 gli orari Oracle.

Sintassi delle query

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

`SELECT` istruzioni

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

Funzioni, operatori ed espressioni

Le sezioni seguenti elencano i mapping tra le funzioni Oracle e gli equivalenti BigQuery.

Operatori di confronto

Gli operatori di confronto 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. Puoi utilizzare REGEXP_CONTAINS anziché REGEXP_LIKE in BigQuery.

Operatore	Descrizione
`"="`	Uguale
`<>`	Non uguale
`!=`	Non uguale
`>`	Maggiore di
`>=`	Maggiore o uguale a
`<`	Meno di
`<=`	Minore o uguale
`IN ( )`	Corrisponde a un valore in un elenco
`NOT`	Nega una condizione
`BETWEEN`	All'interno di un intervallo (incluso)
`IS NULL`	`NULL` value
`IS NOT NULL`	Not `NULL` value
`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.

Funzioni ed espressioni 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 seguente tabella mostra i mapping tra le funzioni di aggregazione comuni di Oracle, le funzioni di aggregazione statistica e le funzioni di aggregazione approssimativa con i relativi equivalenti 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 gli altri 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 NOT bit a 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`	`GROUPING`
`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 per Oracle, non esiste in BigQuery.
`OLAP_EXPRESSION`	Specifico per Oracle, non esiste in BigQuery.
`OLAP_EXPRESSION_BOOL`	Specifico per Oracle, non esiste in BigQuery.
`OLAP_EXPRESSION_DATE`	Specifico per Oracle, non esiste in BigQuery.
`OLAP_EXPRESSION_TEXT`	Specifico per Oracle, non esiste in BigQuery.
`OLAP_TABLE`	Specifico per Oracle, non esiste in BigQuery.
`POWERMULTISET`	Specifico per Oracle, non esiste in BigQuery.
`POWERMULTISET_BY_CARDINALITY`	Specifico per Oracle, non esiste in BigQuery.
`QUALIFY`	Specifico per 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 analitiche

La tabella seguente mostra i mapping tra le funzioni analitiche e aggregate comuni di Oracle e i relativi equivalenti BigQuery.

Oracle	BigQuery
`AVG`	`AVG`
`BIT_COMPLEMENT`	Operatore NOT bit a 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. Valuta la possibilità di utilizzare UDF e BigQuery ML
`FEATURE_DETAILS`	Non esiste implicitamente in BigQuery. Valuta la possibilità di utilizzare UDF e BigQuery ML
`FEATURE_ID`	Non esiste implicitamente in BigQuery. Valuta la possibilità di utilizzare UDF e BigQuery ML
`FEATURE_SET`	Non esiste implicitamente in BigQuery. Valuta la possibilità di utilizzare UDF e BigQuery ML
`FEATURE_VALUE`	Non esiste implicitamente in BigQuery. Valuta la possibilità di utilizzare 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 per Oracle, non esiste in BigQuery.
`PRESENTV`	Specifico per Oracle, non esiste in BigQuery.
`PREVIOUS`	Specifico per 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 UDF.

Funzioni di data/ora

La tabella seguente mostra i mapping 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 punti non vengono utilizzati in BigQuery. Le funzioni definite dall'utente possono essere utilizzate per confrontare due periodi.

BigQuery offre le seguenti funzioni aggiuntive di data/ora:

Funzioni di stringa

La seguente tabella mostra i mapping tra le funzioni stringa Oracle e i relativi equivalenti 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 per Oracle, non esiste in BigQuery.
`POSITION`	`STRPOS(string, substring)`
`PRINTBLOBTOCLOB`	Specifico per 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 funzione definita dall'utente 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 stringa aggiuntive:

Funzioni matematiche

La tabella seguente mostra i mapping tra le funzioni matematiche di Oracle e i relativi equivalenti 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 definita dall'utente personalizzata e la funzione RAND
`RANDOMINTEGER`	`CAST(FLOOR(10*RAND()) AS INT64)`
`RANDOMNUMBER`	Non è supportato in BigQuery. Valuta la possibilità di utilizzare una funzione definita dall'utente personalizzata e la funzione RAND
`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 i mapping tra le funzioni di conversione dei tipi 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 sono necessarie specifiche di Oracle.
`CONVERT`	BigQuery non supporta i set 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 l'utilizzo delle funzioni definite dall'utente
`NCHR`	La funzione definita dall'utente può essere utilizzata per ottenere l'equivalente carattere del binario
`NUMTODSINTERVAL`	Il tipo di dati `INTERVAL` non è supportato in BigQuery
`NUMTOHEX`	Non è supportato in BigQuery. Valuta la possibilità di utilizzare una funzione definita dall'utente personalizzata e la funzione `TO_HEX`
`NUMTOHEX2`
`NUMTOYMINTERVAL`	Il tipo di dati `INTERVAL` non è supportato in BigQuery.
`RAW_TO_CHAR`	Specifico per Oracle, non esiste in BigQuery.
`RAW_TO_NCHAR`	Specifico per Oracle, non esiste in BigQuery.
`RAW_TO_VARCHAR2`	Specifico per Oracle, non esiste in BigQuery.
`RAWTOHEX`	Specifico per Oracle, non esiste in BigQuery.
`RAWTONHEX`	Specifico per Oracle, non esiste in BigQuery.
`RAWTONUM`	Specifico per Oracle, non esiste in BigQuery.
`RAWTONUM2`	Specifico per Oracle, non esiste in BigQuery.
`RAWTOREF`	Specifico per Oracle, non esiste in BigQuery.
`REFTOHEX`	Specifico per Oracle, non esiste in BigQuery.
`REFTORAW`	Specifico per 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 CAST viene utilizzata in una query per indicare che il tipo di risultato di un'espressione deve essere convertito in un altro tipo.
`TREAT`	Specifico per Oracle, non esiste in BigQuery.
`VALIDATE_CONVERSION`	Non è supportato in BigQuery. Valuta la possibilità di utilizzare una funzione definita dall'utente personalizzata
`VSIZE`	Non è supportato in BigQuery. Valuta la possibilità di utilizzare una funzione definita dall'utente personalizzata

Funzioni JSON

La seguente tabella mostra le mappature tra le funzioni JSON di Oracle e le relative funzioni 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 l'utilizzo di 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 l'utilizzo di funzioni definite dall'utente e `JSON_EXTRACT` o `JSON_EXTRACT_SCALAR`.
`JSON_TABLE`	Funzione definita dall'utente personalizzata.
`JSON_TEXTCONTAINS`	Valuta l'utilizzo di funzioni definite dall'utente e `JSON_EXTRACT` o `JSON_EXTRACT_SCALAR`.
`JSON_VALUE`	`JSON_EXTRACT_SCALAR`

Funzioni XML

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

Oracle	BigQuery
`DELETEXML`	Per elaborare 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 pacchetti e licenze di analisi avanzata per eseguire ML sul database. Oracle utilizza il pacchetto DBMS_DATA_MINING per ML. La conversione dei job di Oracle Data Miner richiede la riscrittura del codice. Puoi scegliere tra le offerte complete di Google AI, come BigQuery ML, le API AI (tra cui Speech-to-Text, Text-to-Speech, Dialogflow, Cloud Translation, NLP, Cloud Vision e l'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 carichi di lavoro di addestramento e assegnazione di punteggi su larga scala. La tabella seguente mostra le funzioni Oracle ML:

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 insieme o di array

La tabella seguente mostra le funzioni di insieme 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

Gerarchiche o ricorsive non vengono utilizzate in BigQuery. Se la profondità della gerarchia è nota, è possibile ottenere una funzionalità simile con i join, come illustrato nell'esempio seguente. Un'altra soluzione sarebbe quella di utilizzare l'API BigQuery Storage 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

Il pacchetto UTL_File 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 di file non elaborati. Per leggere e scrivere file da e verso Cloud Storage, devono essere utilizzate le tabelle esterne e le operazioni di caricamento ed esportazione di BigQuery. Per maggiori informazioni, consulta Introduzione alle origini dati esterne.

Funzioni spaziali

Puoi utilizzare l'analisi geospaziale di BigQuery per sostituire la funzionalità spaziale. Esistono SDO_* funzioni e tipi in Oracle, ad esempio SDO_GEOM_KEY, SDO_GEOM_MBR, SDO_GEOM_MMB. Queste funzioni vengono utilizzate per l'analisi spaziale. Puoi utilizzare l'analisi geospaziale per eseguire l'analisi spaziale.

Sintassi DML

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

`INSERT` estratto conto

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 di sessioni e transazioni, consulta la sezione CREATE [UNIQUE] INDEX section in questo documento.

Oracle BigQuery

Oracle	BigQuery
`INSERT INTO table VALUES (...);`	`INSERT INTO table (...) VALUES (...);` Oracle offre una parola chiave `DEFAULT` per le colonne non nullabili. Nota: in BigQuery, l'omissione dei nomi delle colonne nell'istruzione `INSERT` funziona solo se i valori per tutte le colonne nella tabella di destinazione sono inclusi in ordine crescente in base alle loro 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 utilizzare al meglio la quota, valuta i seguenti approcci: Combina più righe in una singola istruzione `INSERT`, anziché una riga per operazione `INSERT`. Combina più istruzioni DML (inclusa `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 nullabili.

Nota: in BigQuery, l'omissione dei nomi delle colonne nell'istruzione INSERT funziona solo se i valori per tutte le colonne nella tabella di destinazione sono inclusi in ordine crescente in base alle loro 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 utilizzare al meglio la quota, valuta i seguenti approcci:

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

`UPDATE` estratto conto

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

Come best practice, dovresti preferire le istruzioni DML batch a più istruzioni UPDATE e INSERT singole. 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 di sessioni e transazioni, consulta la sezione CREATE INDEX di questo documento.

La tabella seguente mostra le istruzioni Oracle UPDATE 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 BigQuery UPDATE nella documentazione DML.

Istruzioni `DELETE` e `TRUNCATE`

Le istruzioni DELETE e TRUNCATE sono due 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 saperne di più 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` estratto conto

L'istruzione MERGE può combinare le operazioni INSERT, UPDATE e DELETE in un'unica istruzione UPSERT ed eseguirle in modo atomico. L'operazione MERGE deve corrispondere al massimo a una riga di origine per ogni riga di destinazione. BigQuery e Oracle seguono 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` estratto conto

La maggior parte delle istruzioni Oracle CREATE TABLE sono compatibili 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, vedi CREATE INDEX.
UNIQUE INDEX. Per ulteriori informazioni, vedi 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 Identity sono state 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 a variazione lenta (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 (in quanto non verranno mantenute più a lungo del TTL del set di dati). Puoi anteporre temp a tutti i nomi delle tabelle in questo set di dati per indicare chiaramente che le tabelle sono temporanee.
TTL tabella:crea una tabella con un breve time to live specifico per la tabella utilizzando istruzioni DDL simili alle seguenti:
```
CREATE TABLE temp.name (col1, col2, ...)

OPTIONS(expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 1 HOUR));
```
Clausola WITH:se è necessaria una tabella temporanea solo all'interno dello stesso blocco, utilizza un risultato temporaneo utilizzando un'istruzione o una sottoquery WITH.

`CREATE SEQUENCE` estratto conto

Le sequenze non vengono utilizzate in BigQuery. Questo risultato può essere ottenuto con il seguente batch. Per ulteriori informazioni sulle chiavi surrogate e sulle dimensioni a variazione lenta (SCD), consulta le seguenti guide:

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

`CREATE VIEW` estratto conto

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 già nel set di dati specificato.

`CREATE MATERIALIZED VIEW` estratto conto

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 a una pianificazione) in BigQuery. Per saperne di più, consulta Introduzione alle viste materializzate.

Se la tabella di base continua a cambiare solo per aggiunte, la query che utilizza la vista materializzata (indipendentemente dal fatto che la vista sia esplicitamente referenziata o selezionata dall'ottimizzatore delle query) esegue la scansione di tutta la vista materializzata più un delta nella tabella di base dall'ultimo aggiornamento della vista. Ciò significa che le query sono più veloci ed economiche.

Al contrario, se nella tabella di base sono stati eseguiti aggiornamenti (DML UPDATE / MERGE) o eliminazioni (DML DELETE, troncamento, scadenza della partizione) dall'ultimo aggiornamento della vista, la vista materializzata non viene analizzata e quindi la query non ottiene 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 analizzato completamente indipendentemente dall'utilizzo 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` estratto conto

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 perché è un database orientato alle colonne 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, un indice univoco può essere utilizzato 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 e viene segnalata 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 di staging, eliminando i record duplicati. Tuttavia, non esiste alcun modo per 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 gestione temporanea, 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 downstream.

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

Chiusura

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

Istruzioni SQL procedurali

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

`CREATE PROCEDURE` estratto conto

La stored procedure è supportata nell'ambito della versione beta di BigQuery Scripting.

Oracle	BigQuery	Note
`CREATE PROCEDURE`	`CREATE PROCEDURE`	Come Oracle, BigQuery supporta le modalità di argomento `IN, OUT, INOUT`. Altre specifiche della 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` estratto conto

I trigger non vengono utilizzati in BigQuery. La logica dell'applicazione basata sulle righe deve essere gestita nel livello dell'applicazione. La funzionalità di attivazione può essere ottenuta utilizzando lo strumento di importazione, le funzioni Pub/Sub e/o Cloud Run durante il tempo di importazione o utilizzando scansioni regolari.

Dichiarazione e assegnazione di variabili

La tabella seguente mostra le istruzioni Oracle DECLARE 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 Oracle e il suo equivalente BigQuery:

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

Istruzioni di flusso di controllo

La tabella seguente mostra le istruzioni di flusso di controllo Oracle e i relativi equivalenti 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 dello snapshot. Per maggiori dettagli, consulta Garanzie di coerenza e isolamento delle transazioni in questo documento.
`EXPLAIN PLAN ...`	Non utilizzato in BigQuery. Funzionalità simili sono la spiegazione del piano di query nella UI web di BigQuery e l'allocazione degli slot, nonché il logging di controllo in Stackdriver.
`SELECT * FROM DBA_[*];` (Oracle DBA_/ALL_/V$ views)	`SELECT * FROM mydataset.INFORMATION_SCHEMA.TABLES;` Per ulteriori informazioni, vedi Introduzione a BigQuery INFORMATION_SCHEMA.
`SELECT * FROM GV$SESSION;` `SELECT * FROM V$ACTIVE_SESSION_HISTORY;`	BigQuery non ha il concetto tradizionale di sessione. Puoi visualizzare i job di query nella UI o esportare i log di controllo Stackdriver in BigQuery e analizzare i log di BigQuery per analizzare i job. Per saperne di più, vedi Visualizzare i dettagli del 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 equivale a 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 su più righe e con più istruzioni

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

Codici e messaggi di errore

I codici di errore Oracle e i codici di errore BigQuery sono diversi. Se la logica dell'applicazione rileva attualmente gli errori, prova a eliminare l'origine 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 in molte righe. Ad esempio, un'operazione MERGE è atomica, anche con più valori inseriti e aggiornati.

Transazioni

Oracle fornisce livelli di isolamento delle transazioni serializzabili o di lettura confermata. Sono possibili deadlock. I job di accodamento degli inserimenti Oracle vengono eseguiti in modo indipendente.

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

Esegui il rollback

Oracle supporta i rollback. Poiché non esiste un limite di transazione esplicito in BigQuery, non esiste il concetto di rollback esplicito in BigQuery. Le soluzioni alternative sono i decorator per tabelle o l'utilizzo di FOR SYSTEM_TIME AS OF.

Limiti per i database

Controlla 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 tra i limiti dei database Oracle e BigQuery.

Limite	Oracle	BigQuery
Tabelle per database	Senza restrizioni	Senza restrizioni
Colonne per tabella	1000	10.000
Dimensione massima della riga	Illimitato (dipende dal tipo di colonna)	100 MB
Lunghezza del nome di colonne e 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 (dimensione massima delle query GoogleSQL non risolte) 12 MB (dimensione massima delle query legacy e GoogleSQL risolte) Streaming: 10 MB (dimensione massima della richiesta HTTP) 10.000 (numero massimo di righe per richiesta)
Dimensioni massime di richiesta e risposta	Illimitato	10 MB (richiesta) e 10 GB (risposta) o 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 del tipo di dati, limiti del database fisico, limiti del database logico e limiti di processo e runtime.