Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Guida alla traduzione SQL di Oracle

Questo documento descrive in dettaglio le somiglianze 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 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 all'utente 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 maggiore di quella supportata da BigQuery. Inoltre, prima di memorizzare un numero decimale, Oracle arrotonda per eccesso se il numero ha più cifre dopo il separatore decimale rispetto a 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 potrebbe essere definita in modo da avere una scala maggiore di quella supportata da BigQuery. Inoltre, prima di memorizzare un numero decimale, Oracle arrotonda per eccesso se il numero ha più cifre dopo il separatore decimale rispetto a 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, un 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 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 per eccesso a un numero intero. Per BigQuery, un 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 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 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 sarebbe inserire gli oggetti binari in Cloud Storage e conservare i riferimenti in BigQuery.
`BLOB`	`BYTES`	Il tipo di dati `BYTES` può essere utilizzato per archiviare 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 all'ora UTC. In BigQuery, è necessario eseguire manualmente una conversione del fuso orario per far corrispondere la 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 all'ora UTC. In BigQuery, è necessario eseguire manualmente una conversione del fuso orario per far corrispondere la 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 all'ora UTC. In BigQuery, è necessario eseguire manualmente una conversione del fuso orario per far corrispondere la 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 all'ora UTC. In BigQuery, è necessario eseguire manualmente una conversione del fuso orario per far corrispondere la 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 archiviare 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 archiviare 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, il campo `ROWID` o `UROWID` non deve essere utilizzato nelle applicazioni. In questo caso, però, è possibile utilizzare il tipo di dati `STRING` per conservare questi dati.

Formattazione del testo

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 su 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 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 dei tipi 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.

Tieni presente che non sono presenti 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 della colonna o impostando la 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 base allo standard 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 cast esplicito di una stringa. Ad esempio, la seguente espressione restituisce sempre un separatore di spazio: `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. Internamente, si tratta di numeri con lunghezza fissa. Oracle utilizza il tipo 13 quando una data viene restituita 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é è basato 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 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 lo standard ISO 8601, quindi assicurati di convertire le date e gli orari di Oracle.

Sintassi delle query

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

`SELECT` istruzioni

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

Funzioni, operatori ed espressioni

Le sezioni seguenti elencano le mappature tra le funzioni Oracle e gli equivalenti 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. Puoi utilizzare REGEXP_CONTAINS anziché REGEXP_LIKE in BigQuery.

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

Gli operatori della 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 di aggregazione, aggregazione statistica e aggregazione approssimativa 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 gli altri argomenti definiti da Oracle.
`APPROX_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 per 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 le 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 l'utilizzo di UDF.
`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 analitiche

La tabella seguente mostra le mappature tra le funzioni analitiche e di aggregazione analitica comuni di Oracle e i loro equivalenti in BigQuery.

Oracle	BigQuery
`AVG`	`AVG`
`BIT_COMPLEMENT`	Operatore NOT bit per 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 funzione definita dall'utente personalizzata
`CUME_DIST`	`CUME_DIST`
`DENSE_RANK(ANSI)`	`DENSE_RANK`
`FEATURE_COMPARE`	Non esiste implicitamente in BigQuery. Valuta l'utilizzo di funzioni definite dall'utente e BigQuery ML
`FEATURE_DETAILS`	Non esiste implicitamente in BigQuery. Valuta l'utilizzo di funzioni definite dall'utente e BigQuery ML
`FEATURE_ID`	Non esiste implicitamente in BigQuery. Valuta l'utilizzo di funzioni definite dall'utente e BigQuery ML
`FEATURE_SET`	Non esiste implicitamente in BigQuery. Valuta l'utilizzo di funzioni definite dall'utente e BigQuery ML
`FEATURE_VALUE`	Non esiste implicitamente in BigQuery. Valuta l'utilizzo di funzioni definite dall'utente 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 una funzione definita 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 funzione definita dall'utente 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 UDF possono essere utilizzate per confrontare due periodi.

BigQuery offre le seguenti funzioni di data/ora aggiuntive:

Funzioni di stringa

La seguente tabella mostra le mappature tra le funzioni di 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 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 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 seguente tabella 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 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 dei tipi

La tabella seguente mostra le mappature 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 informazioni specifiche di Oracle.
`CONVERT`	BigQuery non supporta i set di caratteri. Valuta la possibilità di utilizzare funzione definita dall'utente dall'utente.
`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 di funzioni definite dall'utente
`NCHR`	La funzione definita dall'utente può essere utilizzata per ottenere l'equivalente in caratteri del file 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 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 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 di 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 i loro equivalenti 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 UDF 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. 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 l'XML, è possibile utilizzare le funzioni definite dall'utente 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 un pacchetto di analisi avanzate e licenze per eseguire il ML sul database. Oracle utilizza il pacchetto DBMS_DATA_MINING per il machine learning. La conversione dei job di Oracle Data Miner richiede la riscrittura del codice per l'utilizzo con le funzionalità di BigQuery. Puoi scegliere tra le complete offerte di Google AI, tra cui i seguenti prodotti e funzionalità:

Puoi utilizzare BigQuery ML o gli strumenti per sviluppatori di Agent Platform per sviluppare, addestrare e valutare i modelli di ML.

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 set o array

La seguente tabella 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

In BigQuery non vengono utilizzate query gerarchiche o ricorsive. Se la profondità della gerarchia è nota, è possibile ottenere una funzionalità simile con i join, come illustrato nell'esempio seguente. Un'altra soluzione sarebbe 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. Le tabelle esterne e le operazioni di caricamento ed esportazione di BigQuery devono essere utilizzate per leggere e scrivere file da e verso Cloud Storage. Per saperne di più, consulta Introduzione alle origini dati esterne.

Funzioni spaziali

Puoi utilizzare l'analisi geospaziale di BigQuery per sostituire la funzionalità spaziale. In Oracle sono presenti funzioni e tipi SDO_*, come 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` istruzioni

La maggior parte delle istruzioni Oracle INSERT è 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 più avanti 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 nullable. 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 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, tieni presente i seguenti approcci: Combina più righe in un'unica istruzione `INSERT`, anziché una riga per operazione `INSERT`. Combina più istruzioni DML (tra cui `INSERT`) utilizzando un'istruzione `MERGE`. Utilizza `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 nullable.

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 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, tieni presente i seguenti approcci:

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

`UPDATE` istruzioni

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, è preferibile utilizzare istruzioni DML batch anziché 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 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 Oracle UPDATE e le istruzioni BigQuery che eseguono le stesse attività.

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

`DELETE` e `TRUNCATE` istruzioni

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 saperne di più su DELETE in BigQuery, consulta gli esempi di DELETE di BigQuery nella documentazione di DML.

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

`MERGE` istruzioni

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, al massimo, a una riga di origine per ogni riga di destinazione. Sia BigQuery che Oracle seguono 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` istruzioni

La maggior parte delle istruzioni Oracle CREATE TABLE è 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 saperne di più, consulta CREATE INDEX.
UNIQUE INDEX. Per saperne di più, consulta CREATE INDEX.
CONSTRAINT..REFERENCES
DEFAULT
PARALLEL
COMPRESS

Per saperne di più su CREATE TABLE in BigQuery, consulta gli esempi di CREATE TABLE di BigQuery.

Opzioni e attributi delle colonne

Le colonne di identità 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 saperne di più 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 tabelle temporanee, che vengono spesso utilizzate per archiviare 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 una durata (TTL) breve (ad esempio un'ora) in modo che tutte le tabelle create nel set di dati siano effettivamente temporanee (poiché non persisteranno oltre la durata del set di dati). Puoi aggiungere il prefisso temp a tutti i nomi delle tabelle in questo set di dati per indicare chiaramente che le tabelle sono temporanee.
TTL della tabella: crea una tabella con una durata limitata specifica 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` istruzioni

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 a variazione lenta (SCD), consulta le seguenti guide:

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

`CREATE VIEW` istruzioni

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` istruzioni

In BigQuery, le operazioni di aggiornamento delle vista materializzata vengono eseguite automaticamente. Non è necessario specificare le opzioni di aggiornamento (ad esempio, on commit o on schedule) in BigQuery. Per saperne di più, consulta Introduzione alle viste 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 indicata o selezionata dall'ottimizzatore delle query) analizza l'intera 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, di conseguenza, la query non genera risparmi fino al successivo aggiornamento della vista. In pratica, qualsiasi aggiornamento o eliminazione nella tabella di base invalida lo stato della vista materializzata.

Inoltre, i dati del buffer di flussi della tabella di base non vengono salvati nella vista materializzata. Il buffer di flussi di dati 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` istruzioni

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

Indicizzazione per le prestazioni

BigQuery non ha bisogno di indici espliciti, perché è un database orientato alle colonne con ottimizzazione delle query e dello spazio di archiviazione. BigQuery offre funzionalità come il partizionamento e il clustering, nonché i campi nidificati, che possono aumentare l'efficienza e le prestazioni delle query ottimizzando il modo in cui vengono archiviati i dati.

Indicizzazione per garantire la 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 con 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 gestione temporanea, ignorando 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 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).

Blocco in corso…

BigQuery non ha un meccanismo di blocco come Oracle e può eseguire query simultanee (fino alla tua quota). Solo le istruzioni DML hanno determinati limiti di contemporaneità 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 in stored procedure, funzioni e trigger da Oracle a BigQuery.

`CREATE PROCEDURE` istruzioni

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

Oracle	BigQuery	Note
`CREATE PROCEDURE`	`CREATE PROCEDURE`	Analogamente a Oracle, BigQuery supporta le modalità di argomento `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` istruzioni

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

Dichiarazione e assegnazione di variabili

La seguente tabella 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 controllo del flusso di Oracle e i relativi equivalenti in 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 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 nell'interfaccia utente web di BigQuery e l'allocazione degli slot, nonché l'audit logging in Stackdriver.
`SELECT * FROM DBA_[*];` (Viste Oracle DBA_/ALL_/V$)	`SELECT * FROM mydataset.INFORMATION_SCHEMA.TABLES;` Per saperne di più, consulta Introduzione a INFORMATION_SCHEMA di BigQuery.
`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 gli audit log di Stackdriver in BigQuery e analizzare i log di BigQuery per analizzare i job. Per saperne di più, consulta Visualizza 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. Utilizzando 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 più righe

Sia Oracle che BigQuery supportano le transazioni (sessioni) e, di conseguenza, le istruzioni separate da punti e virgola che vengono eseguite insieme in modo coerente. Per saperne di più, consulta Transazioni con più istruzioni.

Codici e messaggi di errore

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

Transazioni

Oracle fornisce livelli di isolamento delle transazioni read committed o serializzabili. Sono possibili deadlock. I job di inserimento e aggiunta di Oracle vengono eseguiti in modo indipendente.

BigQuery supporta anche le transazioni. BigQuery contribuisce a garantire il controllo della concorrenza ottimistica (vince il primo commit) con l'isolamento degli snapshot, in cui una query legge gli ultimi dati di cui è stato eseguito il commit prima dell'avvio 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. In 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 e i job di caricamento INSERT possono essere eseguiti contemporaneamente e in modo indipendente per aggiungere 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. Le soluzioni alternative sono i decoratori di 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 dei 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 dei nomi di colonne e tabelle	Se v12.2>= 128 byte Else 30 Bytes	16.384 caratteri Unicode
Righe per tabella	Illimitato	Illimitato
Lunghezza massima della richiesta SQL	Illimitato	1 MB (lunghezza massima della query GoogleSQL non risolta) 12 MB (lunghezza massima della query legacy e GoogleSQL risolta) Streaming: 10 MB (limite di dimensioni 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 l'impaginazione 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 contemporaneità; 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 runtime.