4504 lines
218 KiB
TypeScript
4504 lines
218 KiB
TypeScript
import { withEnglishFallback } from "./fallback";
|
||
export default withEnglishFallback({
|
||
app: {
|
||
name: "DBX",
|
||
},
|
||
auth: {
|
||
setupTitle: "Imposta la password di accesso",
|
||
setupDescription: "Imposta una password per proteggere la tua istanza",
|
||
loginDescription: "Strumento di gestione del database",
|
||
newPassword: "Inserisci la nuova password",
|
||
confirmPassword: "Conferma la password",
|
||
enterPassword: "Inserisci la password di accesso",
|
||
passwordMismatch: "Le password non corrispondono",
|
||
setPassword: "Imposta Password",
|
||
login: "Accedi",
|
||
processing: "Elaborazione...",
|
||
loginFailed: "Password errata",
|
||
connectFailed: "Connessione non riuscita",
|
||
changePassword: "Cambia Password",
|
||
oldPassword: "Password attuale",
|
||
oldPasswordWrong: "La password attuale non è corretta",
|
||
passwordChanged: "Password modificata con successo",
|
||
changePasswordFailed: "Impossibile modificare la password",
|
||
changePasswordDescription: "Inserisci la password attuale e scegline una nuova",
|
||
},
|
||
toolbar: {
|
||
newConnection: "Nuova Connessione",
|
||
newQuery: "Nuova Query",
|
||
execute: "Esegui",
|
||
executeShortcut: "Esegui selezione/query (Cmd+Enter)",
|
||
stopQuery: "Interrompi query",
|
||
explainPlan: "Spiega piano",
|
||
stopExplain: "Interrompi spiegazione",
|
||
formatSql: "Formatta SQL",
|
||
formatSqlFailed: "Impossibile formattare SQL",
|
||
keywordCaseLower: "Usa parole chiave SQL minuscole",
|
||
keywordCaseUpper: "Usa parole chiave SQL maiuscole",
|
||
autoCommit: "Auto Commit",
|
||
manualTransaction: "Transazione Manuale",
|
||
autoCommitAgent: "Auto Commit (dipende dal backend dell'Agente)",
|
||
manualTransactionAgent: "Transazione Manuale (dipende dal backend dell'Agente)",
|
||
commit: "Commit",
|
||
rollback: "Rollback",
|
||
txnAutoRolledBack: "Transazione annullata automaticamente dopo 5 minuti di inattività",
|
||
previewSql: "Anteprima SQL",
|
||
previewQuery: "Anteprima query",
|
||
hidePreviewSql: "Nascondi anteprima SQL",
|
||
saveSql: "Salva nella Libreria SQL",
|
||
openSql: "Apri file SQL",
|
||
exPasteSqlInCondition: "ExPaste: incolla come condizione IN",
|
||
theme: "Tema",
|
||
themeLight: "Chiaro",
|
||
themeDark: "Scuro",
|
||
themeSystem: "Segui Sistema",
|
||
sqlSaved: "SQL salvato",
|
||
sqlOpenFailed: "Impossibile aprire il file: {message}",
|
||
sqlSaveFailed: "Impossibile salvare il file: {message}",
|
||
driverManager: "Gestione Driver",
|
||
updatableDriverCount: "Driver aggiornabili",
|
||
blockDangerousRedisCommands: "Blocca comandi pericolosi",
|
||
},
|
||
updates: {
|
||
title: "Aggiornamenti",
|
||
check: "Verifica aggiornamenti",
|
||
availableTitle: "Aggiornamento disponibile",
|
||
availableMessage: "DBX {latest} è disponibile. Stai usando la versione {current}.",
|
||
upToDate: "DBX è aggiornato ({version}).",
|
||
failed: "Verifica aggiornamenti non riuscita: {error}",
|
||
rateLimited: "Le verifiche degli aggiornamenti di GitHub sono temporaneamente limitate. Puoi comunque aprire la pagina delle release per verificare manualmente.",
|
||
openRelease: "Apri Release",
|
||
downloadAndInstall: "Scarica e Installa",
|
||
portableManualUpdate: "Le build portatili non possono utilizzare l'installer in-app. Scarica lo ZIP portatile dalla pagina delle release, quindi estrailo nella cartella DBX corrente per mantenere portable.dbx e i dati.",
|
||
downloading: "Download in corso {progress}%",
|
||
downloadFailed: "Download dell'aggiornamento non riuscito: {error}",
|
||
restart: "Esci e Riavvia",
|
||
restartFailed: "Impossibile riavviare l'app: {error}",
|
||
exitAndUpdate: "Esci e Aggiorna",
|
||
dockerUsersRun: "Gli utenti Docker dovrebbero eseguire",
|
||
toUpdate: "per aggiornare",
|
||
},
|
||
sidebar: {
|
||
connections: "CONNESSIONI",
|
||
noConnections: "Nessuna connessione",
|
||
import: "Importa Connessioni",
|
||
importDbx: "Importa Configurazione DBX",
|
||
importNavicat: "Importa Navicat NCX",
|
||
importDbeaver: "Importa DBeaver",
|
||
importDatagrip: "Importa DataGrip",
|
||
export: "Esporta Connessioni",
|
||
collapseAll: "Riduci tutto",
|
||
collapse: "Riduci barra laterale",
|
||
expand: "Espandi barra laterale",
|
||
showMore: "Mostra altri {count}...",
|
||
filterByType: "Filtra per tipo",
|
||
searchScopeConnection: "Connessione",
|
||
searchScopeDatabase: "Database",
|
||
searchScopeSchema: "Schema",
|
||
searchScopeTable: "Tabella",
|
||
searchScopeView: "Vista",
|
||
searchTablesInCurrentScope: "Cerca tabelle in questo database...",
|
||
clearTableSearch: "Cancella ricerca tabelle",
|
||
clearFilter: "Cancella filtro",
|
||
locateActiveTab: "Trova nella barra laterale",
|
||
},
|
||
savedSql: {
|
||
saveToLibrary: "Salva nella Libreria SQL",
|
||
saveToFile: "Salva localmente",
|
||
save: "Salva",
|
||
saved: "SQL salvato",
|
||
saveFailed: "Impossibile salvare SQL: {message}",
|
||
fileName: "Nome file",
|
||
folder: "Cartella",
|
||
rootFolder: "Libreria SQL",
|
||
newQuery: "Nuova query",
|
||
newFolder: "Nuova Cartella SQL",
|
||
newFolderDefault: "Nuova Cartella",
|
||
renameFolder: "Rinomina Cartella",
|
||
deleteFolder: "Elimina Cartella",
|
||
deleteFolderConfirm: "Eliminare “{name}” e tutti i file SQL al suo interno?",
|
||
open: "Apri SQL",
|
||
renameFile: "Rinomina SQL",
|
||
deleteFile: "Elimina SQL",
|
||
deleteFileConfirm: "Eliminare “{name}”?",
|
||
},
|
||
sqlLibrary: {
|
||
title: "Libreria SQL",
|
||
empty: "Nessuna query salvata",
|
||
emptyFolder: "Cartella vuota",
|
||
unfiled: "Non categorizzati",
|
||
exportFile: "Esporta SQL",
|
||
exportFolder: "Esporta cartella",
|
||
exportLibrary: "Esporta libreria SQL",
|
||
importDirectory: "Importa cartella locale",
|
||
importIntoFolder: "Importa in questa cartella",
|
||
openStorageDirectory: "Apri directory SQL",
|
||
chooseSyncDirectory: "Imposta directory di sincronizzazione locale",
|
||
disableSyncDirectory: "Disattiva sincronizzazione locale",
|
||
syncDirectorySaved: "Directory di sincronizzazione locale SQL salvata",
|
||
syncDirectoryDisabled: "Sincronizzazione locale SQL disattivata",
|
||
syncDirectoryFailed: "Impossibile impostare la directory di sincronizzazione: {message}",
|
||
openDirectoryFailed: "Impossibile aprire la directory: {message}",
|
||
noSyncDirectory: "Imposta prima una directory di sincronizzazione locale",
|
||
exported: "Esportato",
|
||
exportFailed: "Esportazione non riuscita: {message}",
|
||
importFailed: "Importazione non riuscita: {message}",
|
||
importNone: "Nessun file .sql trovato nella cartella selezionata",
|
||
imported: "Importati {count} file SQL",
|
||
desktopOnly: "Questa funzione è disponibile solo su desktop",
|
||
noConnection: "Nessuna connessione disponibile per l'importazione",
|
||
batchDelete: "Eliminazione in blocco",
|
||
batchDeleteConfirm: "Sei sicuro di voler eliminare {count} elementi selezionati? Questa azione non può essere annullata.",
|
||
batchDeleteSuccess: "{count} elementi eliminati con successo",
|
||
moveToFolder: "Sposta nella cartella...",
|
||
moveSelectedToFolder: "Sposta {count} SQL nella cartella...",
|
||
moveSuccess: "{count} SQL spostati",
|
||
clearSelection: "Cancella selezione",
|
||
sortByDate: "Ordina per data di modifica",
|
||
sortByFolder: "Ordina per struttura cartelle",
|
||
},
|
||
|
||
connection: {
|
||
title: "Nuova Connessione",
|
||
name: "Nome",
|
||
namePlaceholder: "Nome connessione, generato automaticamente se vuoto",
|
||
type: "Tipo",
|
||
host: "Host",
|
||
filePath: "Percorso File",
|
||
h2FileMode: "File",
|
||
h2TcpMode: "TCP",
|
||
h2FilePathRequired: "Il percorso del file H2 non può essere vuoto",
|
||
createDuckDbFile: "Crea file DuckDB",
|
||
createSqliteFile: "Crea database SQLite",
|
||
memoryDatabasePathHint: "Usa :memory: per creare un database SQLite o DuckDB in memoria.",
|
||
sqliteCipherKey: "Chiave SQLCipher",
|
||
sqliteCipherKeyPlaceholder: "Lascia vuoto per SQLite non cifrato",
|
||
sqliteExtensions: "Estensioni SQLite",
|
||
sqliteExtensionsPlaceholder: "/percorso/per/regexp.dylib\n/percorso/per/text.dylib|sqlite3_text_init",
|
||
sqliteExtensionsHint: "Una .dylib/.so/.dll per riga. Usa “percorso|punto di ingresso” quando è richiesto un punto di ingresso. Caricata alla connessione, poi load_extension viene disabilitata.",
|
||
initScript: "Script di inizializzazione",
|
||
initScriptPlaceholder: "INSTALL quack;\nLOAD quack;\nATTACH 'quack:host' AS remote (TOKEN '...');",
|
||
initScriptHint: "Istruzioni SQL eseguite a ogni apertura della connessione (INSTALL/LOAD, SET, CREATE SECRET, ATTACH ...). I database collegati qui appaiono nella barra laterale.",
|
||
sqliteExtensionBrowse: "Seleziona estensione SQLite",
|
||
user: "Utente",
|
||
password: "Password",
|
||
database: "Database",
|
||
databasePlaceholder: "Opzionale",
|
||
databasePlaceholderRequired: "Obbligatorio, inserisci un database esistente",
|
||
databasePlaceholderWithDefault: "Opzionale, predefinito {database}",
|
||
kingbaseDatabaseRequired: "Kingbase richiede un database esistente prima di connettersi o caricare l'elenco dei database.",
|
||
defaultDatabase: "DB Predefinito",
|
||
authDatabase: "DB di Autenticazione",
|
||
authDatabasePlaceholder: "Opzionale, spesso admin",
|
||
authMechanism: "Meccanismo di Autenticazione",
|
||
authMechanismDefault: "Predefinito",
|
||
driverMode: "Driver",
|
||
mongoDriverAuto: "Automatico",
|
||
mongoDriverLegacy: "Legacy",
|
||
serviceName: "Servizio/SID",
|
||
serviceNameOnly: "Nome Servizio",
|
||
version: "Versione",
|
||
driverInstallHintPrefix: "Installa il driver richiesto da ",
|
||
driverInstallHintSuffix: " nella barra degli strumenti superiore prima di connetterti.",
|
||
driverName: "Nome Driver",
|
||
driverNamePlaceholder: "Nome del fornitore o dell'ambiente",
|
||
urlParams: "Parametri URL",
|
||
d1AccountId: "ID account",
|
||
d1DatabaseId: "ID database",
|
||
d1ApiToken: "Token API",
|
||
d1TokenHint: "Il token richiede almeno l'autorizzazione D1 Read; per scritture, DDL e importazioni è necessaria anche D1 Write.",
|
||
d1FieldsRequired: "Sono obbligatori l'ID account Cloudflare, l'ID database D1 e il token API.",
|
||
gbaseServer: "GBASEDBTSERVER",
|
||
informixServer: "INFORMIXSERVER",
|
||
sslEnable: "Abilita connessione crittografata",
|
||
caCertPath: "Certificato CA",
|
||
caCertPathPlaceholder: "Opzionale, es. ~/.yandex/RootCA.crt",
|
||
caCertPathBrowse: "Sfoglia certificato",
|
||
redisTlsInsecure: "Salta verifica certificato",
|
||
redisTlsInsecureHint: "Equivalente a redis-cli --tls --insecure, per certificati auto-firmati o CA private.",
|
||
mysqlTlsMode: "Modalità TLS",
|
||
mysqlTlsModePreferred: "Preferita",
|
||
mysqlTlsModeDisabled: "Disabilitata",
|
||
mysqlTlsModeRequired: "Richiesta",
|
||
mysqlTlsModeVerifyCa: "Verifica CA",
|
||
mysqlTlsModeVerifyIdentity: "Verifica Identità",
|
||
mysqlCleartextPasswordAuth: "Autenticazione password in chiaro",
|
||
mysqlCleartextPasswordAuthHint: "Attiva solo quando il server MySQL richiede il plugin di autenticazione password in chiaro.",
|
||
mysqlCaCertHint: "Richiesto per Verifica CA e Verifica Identità quando il certificato del server usa una CA privata.",
|
||
mysqlClientCert: "Autenticazione Client",
|
||
mysqlClientCertPlaceholder: "/percorso/per/client.crt",
|
||
mysqlClientKeyPlaceholder: "/percorso/per/client.key",
|
||
mysqlClientCertHint: "Il certificato client e la chiave privata devono essere forniti insieme quando MySQL richiede mTLS.",
|
||
mysqlTlsConnectionFailureHint: "Se il server MySQL non richiede TLS, modifica la connessione, imposta la modalità TLS su Disabilitata e riprova.",
|
||
mysqlClientCertBrowse: "Scegli certificato client",
|
||
mysqlClientKeyBrowse: "Scegli chiave privata client",
|
||
postgresSslMode: "Modalità TLS",
|
||
postgresSslModeDisable: "Disabilita",
|
||
postgresSslModePrefer: "Preferisci",
|
||
postgresSslModeRequire: "Richiedi",
|
||
postgresSslModeVerifyCa: "Verifica CA",
|
||
postgresSslModeVerifyFull: "Verifica Completa",
|
||
postgresServerCert: "CA Server",
|
||
postgresRootCertPlaceholder: "/percorso/per/ca.crt",
|
||
postgresRootCertHint: "Usa questo per verifica-ca o verifica-completa quando il certificato del server è firmato da una CA privata.",
|
||
postgresRootCertBrowse: "Scegli certificato CA",
|
||
postgresClientCert: "Autenticazione Client",
|
||
postgresClientCertPlaceholder: "/percorso/per/client.crt",
|
||
postgresClientKeyPlaceholder: "/percorso/per/client.key",
|
||
postgresClientCertHint: "Il certificato client e la chiave privata devono essere forniti insieme quando PostgreSQL richiede mTLS.",
|
||
postgresClientCertBrowse: "Scegli certificato client",
|
||
postgresClientKeyBrowse: "Scegli chiave privata client",
|
||
connectionUrlOptional: "URL (opzionale)",
|
||
connectionUrlPlaceholder: "postgresql://utente:password{'@'}host:5432/db?sslmode=require",
|
||
parseConnectionUrl: "Analizza URL di connessione",
|
||
parseConnectionUrlApplied: "URL di connessione applicato",
|
||
parseConnectionUrlFailed: "Impossibile analizzare l'URL di connessione: {message}",
|
||
mode: "Modalità Connessione",
|
||
modeForm: "Modulo",
|
||
redisStandaloneMode: "Standalone",
|
||
redisSentinelMode: "Sentinel",
|
||
redisClusterMode: "Cluster",
|
||
oceanbaseMySQLMode: "Modalità MySQL",
|
||
oceanbaseOracleMode: "Modalità Oracle",
|
||
redisFirstSentinel: "Primo Sentinel",
|
||
redisFirstClusterNode: "Primo Nodo Seed",
|
||
redisSentinelNodes: "Nodi Sentinel",
|
||
redisClusterNodes: "Nodi Seed Cluster",
|
||
redisSentinelMaster: "Nome Master",
|
||
redisSentinelUser: "Utente Sentinel",
|
||
redisSentinelPassword: "Password Sentinel",
|
||
redisSentinelTls: "TLS Sentinel",
|
||
redisSentinelTlsHint: "Usa TLS quando ti connetti ai nodi Sentinel",
|
||
redisKeySeparator: "Separatore namespace chiavi",
|
||
etcdEndpoints: "Endpoint",
|
||
etcdEndpointsHint: "Un endpoint per riga. Lascia vuoto per usare l'host e la porta sopra.",
|
||
etcdCaCertPlaceholder: "/percorso/per/ca.crt",
|
||
etcdCaCertBrowse: "Scegli certificato CA",
|
||
etcdClientAuth: "Autenticazione Client",
|
||
etcdClientCertPlaceholder: "/percorso/per/client.crt",
|
||
etcdClientKeyPlaceholder: "/percorso/per/client.key",
|
||
etcdClientCertHint: "Il certificato client e la chiave privata devono essere forniti insieme quando etcd richiede mTLS.",
|
||
etcdClientCertBrowse: "Scegli certificato client",
|
||
etcdClientKeyBrowse: "Scegli chiave privata client",
|
||
etcdClientCertPairRequired: "Il certificato client e la chiave privata devono essere forniti insieme.",
|
||
zookeeperConnectString: "Stringa di connessione",
|
||
zookeeperConnectStringHint: "Voci host:porta separate da virgola o da riga. Lascia vuoto per usare l'host e la porta sopra.",
|
||
zookeeperCreateModePersistent: "Persistente",
|
||
zookeeperCreateModeEphemeral: "Effimero",
|
||
zookeeperCreateModePersistentSequential: "Persistente Sequenziale",
|
||
zookeeperCreateModeEphemeralSequential: "Effimero Sequenziale",
|
||
nacosConsoleUrl: "URL console",
|
||
nacosConsoleUrlHint: "Usa l'indirizzo console/admin API di Nacos. Nacos 3 Docker di solito espone la console su 8085; distribuzioni più vecchie possono condividere 8848 con la porta di servizio.",
|
||
nacosConsoleUrlRequired: "L'URL console Nacos è obbligatorio",
|
||
nacosConsoleUrlAutoAdjusted: "URL console Nacos regolato da {from} a {to}.",
|
||
nacosNamespace: "Namespace",
|
||
nacosContextPath: "Context Path",
|
||
nacosContextPathPlaceholder: "Lascia vuoto o /nacos",
|
||
nacosAuth: "Autenticazione",
|
||
nacosAuthNone: "Nessuna",
|
||
nacosAuthUserPassword: "Utente / Password",
|
||
nacosUsernameRequired: "Il nome utente Nacos è obbligatorio",
|
||
nacosTls: "TLS",
|
||
nacosTlsSkipVerify: "Salta verifica certificato",
|
||
nacosPageSize: "Dimensione pagina",
|
||
searchDatabasePlaceholder: "Cerca tipi di database",
|
||
jdbcConnection: "Connessione JDBC",
|
||
iconView: "Vista icone",
|
||
listView: "Vista elenco",
|
||
selectedDatabase: "Selezionato",
|
||
noDatabaseMatches: "Nessun database corrispondente",
|
||
next: "Avanti",
|
||
back: "Precedente",
|
||
basicTab: "Connessione",
|
||
tlsTab: "TLS/SSL",
|
||
test: "Test",
|
||
testing: "Verifica in corso...",
|
||
copyTestResult: "Copia risultato test",
|
||
sqlServerLegacyCompatibilityMode: "Modalità compatibilità legacy",
|
||
sqlServerLegacyCompatibilityModeEnable: "Abilita",
|
||
sqlServerLegacyCompatibilityModeHint: "Per istanze di SQL Server limitate a TLS 1.0, crittografia solo all'accesso o nessuna crittografia.\nAlcune funzionalità potrebbero essere limitate; usala solo su reti attendibili.",
|
||
sqlServerLegacyCompatibilityComponent: "Componente di compatibilità legacy SQL Server",
|
||
saveAndConnect: "Salva & Connetti",
|
||
save: "Salva",
|
||
editTitle: "Modifica Connessione",
|
||
testSuccess: "Connessione riuscita",
|
||
connecting: "Connessione a {name}...",
|
||
connectSuccess: "Connesso a {name}",
|
||
connectFailed: "Connessione non riuscita: {message}",
|
||
driverNotInstalled: "Il driver {driver} non è installato. Installalo da Gestione Driver.",
|
||
jreNotInstalled: "Il runtime JRE {jre} non è installato. Installalo da Gestione Driver.",
|
||
systemJavaNotFound: "Runtime Java di sistema non trovato in PATH. Installa Java o scegli un eseguibile Java personalizzato.",
|
||
customJavaPathEmpty: "Il percorso del runtime Java personalizzato è vuoto. Scegli un eseguibile Java.",
|
||
agentJavaTooOld: "Questo driver richiede Java 21. Usa il JRE 21 gestito da DBX o seleziona un eseguibile Java 21 in Gestione Driver.",
|
||
agentDriverUpdateConnectionHint: "È disponibile un aggiornamento del driver integrato per questa connessione. Il problema di connessione potrebbe essere correlato a un driver locale obsoleto. Aggiorna il driver corrispondente in Gestione Driver e riprova.",
|
||
jdbcPluginNotInstalled: "Il plugin JDBC non è installato. Installa il plugin JDBC opzionale per utilizzare questa connessione.",
|
||
lastError: "Errore di connessione",
|
||
clearError: "Cancella errore di connessione",
|
||
saveFailed: "Impossibile salvare la connessione: {message}",
|
||
deleted: "Connessione eliminata",
|
||
deletedSelected: "{count} connessioni eliminate",
|
||
copied: "Copiato",
|
||
disconnected: "Disconnesso",
|
||
databaseConnectionClosed: "Connessione al database chiusa: {name}",
|
||
duplicated: "Connessione duplicata",
|
||
duplicatedSelected: "{count} connessioni duplicate",
|
||
groupDeleted: "Gruppo eliminato",
|
||
loadFailed: "Impossibile caricare le connessioni salvate: {message}",
|
||
sshTunnel: "Tunnel SSH / Proxy",
|
||
advancedTab: "Avanzate",
|
||
sshEnable: "Usa tunnel SSH / proxy",
|
||
sshHost: "Host SSH",
|
||
sshHostPlaceholder: "ssh.example.com o un alias da ~/.ssh/config",
|
||
sshUser: "Utente SSH",
|
||
sshAuthMethod: "Metodo di accesso",
|
||
sshAuthMethodPassword: "Password",
|
||
sshAuthMethodKey: "Chiave privata",
|
||
sshAuthMethodNone: "Nessuno",
|
||
sshAuthMethodNoneHint: "Non verrà inviata alcuna credenziale. Usalo per bastion host o proxy che accettano connessioni senza autenticazione.",
|
||
sshAuthMethodAgentLegacy: "SSH Agent (legacy)",
|
||
sshPassword: "Password SSH",
|
||
sshPasswordPlaceholder: "Lascia vuoto per usare la chiave",
|
||
sshKeyPath: "Percorso Chiave",
|
||
sshKeyPassphrase: "Passphrase Chiave",
|
||
sshKeyPassphrasePlaceholder: "Lascia vuoto se la chiave non è crittografata",
|
||
sshKeyPathBrowse: "Sfoglia",
|
||
sshExposeLan: "Esponi tunnel alla LAN",
|
||
sshConnectTimeout: "Timeout SSH (secondi)",
|
||
sshHops: "Livelli tunnel SSH / proxy",
|
||
sshHopAdd: "Aggiungi livello SSH",
|
||
sshHopDuplicate: "Duplica",
|
||
sshHopDelete: "Elimina",
|
||
sshHopMoveUp: "Sposta su",
|
||
sshHopMoveDown: "Sposta giù",
|
||
sshHopName: "Nome livello",
|
||
sshHopNamePlaceholder: "Bastion, jump host, gateway di produzione",
|
||
sshHopDefaultName: "Livello {index}",
|
||
sshHopInvalidHost: "{hop}: Host SSH richiesto",
|
||
sshHopInvalidUser: "{hop}: Utente SSH richiesto",
|
||
sshHopInvalidPort: "{hop}: La porta SSH deve essere compresa tra 1 e 65535",
|
||
sshHopInvalidAuth: "{hop}: password, percorso chiave o ssh-agent richiesti",
|
||
sshUseAgent: "Usa ssh-agent",
|
||
sshAgentSockPath: "Percorso socket agent",
|
||
sshAgentSockPathPlaceholder: "es. ~/.ssh/agent.sock",
|
||
sshHopInvalidTimeout: "{hop}: Il timeout SSH deve essere compreso tra 1 e 300 secondi",
|
||
connectTimeout: "Timeout Connessione (secondi)",
|
||
queryTimeout: "Timeout Query (secondi)",
|
||
idleTimeout: "Timeout Inattività (secondi)",
|
||
keepaliveInterval: "Intervallo keepalive (secondi)",
|
||
readOnly: "Sola lettura",
|
||
readOnlyHint: "Blocca tutte le operazioni di scrittura (INSERT, UPDATE, DELETE, ecc.)",
|
||
readOnlyBadge: "Sola lettura",
|
||
proxy: "Proxy",
|
||
proxyEnable: "Connetti database tramite proxy",
|
||
proxyType: "Tipo Proxy",
|
||
proxyHost: "Host Proxy",
|
||
proxyUsername: "Utente Proxy",
|
||
proxyUsernamePlaceholder: "Opzionale",
|
||
proxyPassword: "Password Proxy",
|
||
proxyPasswordPlaceholder: "Opzionale",
|
||
tunnelProfile: "Profilo tunnel",
|
||
tunnelProfileCustom: "Personalizzato (solo questa connessione)",
|
||
tunnelProfileManaged: "Gestito da un profilo tunnel condiviso. Modificalo in Impostazioni > Tunnel; le modifiche si applicano a tutte le connessioni che lo usano alla prossima connessione.",
|
||
tunnelProfileMissing: "Il profilo tunnel a cui si fa riferimento non esiste più. Seleziona un altro profilo o passa a personalizzato.",
|
||
tunnelProfileMissingName: "Profilo tunnel mancante",
|
||
tunnelProfileManage: "Gestisci",
|
||
dremioArrowFlightSqlMode: "Arrow Flight SQL",
|
||
dremioLegacyJdbcMode: "JDBC legacy",
|
||
jdbcUrl: "URL JDBC",
|
||
jdbcUrlPlaceholder: "jdbc:postgresql://localhost:5432/database",
|
||
jdbcDriverClass: "Classe Driver (opzionale)",
|
||
jdbcDriverClassPlaceholder: "La maggior parte dei driver si registra automaticamente; usa com.vendor.jdbc.Driver si necessario",
|
||
jdbcDriverPaths: "JAR del Driver",
|
||
jdbcDriverSelectPlaceholder: "Scegli il driver importato",
|
||
jdbcManualClasspath: "Classpath manuale",
|
||
jdbcManualClasspathCount: "{count} percorsi",
|
||
jdbcDriverPathsPlaceholder: "/percorso/per/driver.jar\n/percorso/per/un-altro-driver.jar",
|
||
jdbcDriverBrowse: "Scegli file JAR del driver JDBC",
|
||
jdbcDocs: "Visualizza documentazione JDBC",
|
||
jdbcPluginHint: "Installa prima il plugin DBX JDBC, quindi importa il file JAR del driver JDBC del fornitore del database.",
|
||
dmCompatHint: "Richiede il driver ODBC DM8 installato sul sistema.",
|
||
dmDownload: "Scarica da Dameng",
|
||
mongoLegacyHint: "Usa Legacy per server MongoDB meno recenti, specialmente versioni precedenti alla 4.2. Se l'autenticazione fallisce e l'utente è stato creato in admin, imposta DB di Autenticazione su admin.",
|
||
mongoTlsAllowInvalidCertificates: "Disabilita verifica certificato TLS",
|
||
mongoTlsAllowInvalidCertificatesHint: "Corrisponde a tlsAllowInvalidCertificates=true e disabilita tutta la validazione del certificato, non solo il controllo dell'hostname. Aumenta il rischio MITM. Di solito è necessario per AWS DocumentDB tramite tunnel SSH.",
|
||
mongoRetryWrites: "Riprova scritture",
|
||
mongoRetryWritesHint: "Corrisponde a retryWrites. Disabilitalo per AWS DocumentDB, che non supporta scritture ripetibili.",
|
||
compatible: "Compatibile",
|
||
mainstream: "Popolare",
|
||
color: "Colore",
|
||
colorNone: "Nessun colore",
|
||
colorGreen: "Verde",
|
||
colorYellow: "Giallo",
|
||
colorOrange: "Arancione",
|
||
colorRed: "Rosso",
|
||
colorBlue: "Blu",
|
||
colorPurple: "Viola",
|
||
colorCustom: "Colore personalizzato",
|
||
cancelConnecting: "Annulla connessione",
|
||
connectCancelled: "Connessione annullata",
|
||
kafkaKerberosPrincipal: "Principal",
|
||
kafkaKerberosKeytab: "Keytab",
|
||
kafkaKerberosServiceName: "Nome del servizio",
|
||
kafkaKerberosKrb5Conf: "krb5.conf",
|
||
kafkaKerberosPrincipalRequired: "Kafka Kerberos principal non può essere vuoto",
|
||
kafkaKerberosKeytabRequired: "Il percorso del keytab Kafka Kerberos non può essere vuoto",
|
||
kafkaKerberosKeytabBrowse: "Scegli Keytab",
|
||
kafkaKerberosKrb5ConfBrowse: "Scegli krb5.conf",
|
||
kafkaKerberosKeytabPlaceholder: "Percorso sulla macchina DBX Agent, ad esempio /etc/security/keytabs/user.keytab",
|
||
kafkaKerberosKrb5ConfPlaceholder: "Opzionale, percorso sulla macchina DBX Agent, ad esempio /etc/krb5.conf",
|
||
kafkaKerberosPathHint: "I percorsi di keytab e krb5.conf vengono letti da DBX Agent e devono esistere sulla macchina in cui è in esecuzione DBX Agent; non vengono caricati file dal browser corrente.",
|
||
kafkaKerberosAuthHint: "Accedi con GSSAPI + keytab. Se il server richiede trasmissione crittografata, imposta Security su SASL_SSL; altrimenti puoi utilizzare Auto o SASL_PLAINTEXT.",
|
||
mqSystem: "Sistema",
|
||
mqSystemPulsar: "Apache Pulsar",
|
||
mqSystemKafka: "Apache Kafka",
|
||
mqBootstrapServers: "Bootstrap Servers",
|
||
mqBootstrapServersPlaceholder: "127.0.0.1:9092",
|
||
mqBootstrapServersRequired: "I bootstrap server Kafka sono obbligatori",
|
||
mqBootstrapServersInvalid: "I bootstrap server Kafka non sono validi",
|
||
mqSecurity: "Security",
|
||
mqSecurityAuto: "Auto",
|
||
mqAdminUrl: "Admin URL",
|
||
mqAdminUrlRequired: "L'Admin URL MQ è obbligatorio",
|
||
mqAdminUrlInvalid: "L'Admin URL MQ non è valido",
|
||
mqAuth: "Autenticazione",
|
||
mqAuthNone: "Nessuna",
|
||
mqAuthToken: "Token",
|
||
mqAuthBasic: "Basic",
|
||
mqAuthKerberos: "Kerberos",
|
||
mqAuthApiKey: "API Key",
|
||
mqAuthOauth2: "OAuth2",
|
||
mqToken: "Token",
|
||
mqSaslMechanism: "SASL Mechanism",
|
||
mqApiKeyHeader: "Header",
|
||
mqApiKeyValue: "Value",
|
||
mqOauthIssuerUrl: "Issuer URL",
|
||
mqOauthClientId: "Client ID",
|
||
mqOauthClientSecret: "Client Secret",
|
||
mqOauthAudience: "Audience",
|
||
mqOauthScope: "Scope",
|
||
mqOauthIssuerRequired: "L'autenticazione OAuth2 richiede un Issuer URL",
|
||
mqOauthClientIdRequired: "L'autenticazione OAuth2 richiede un Client ID",
|
||
mqOauthClientSecretRequired: "L'autenticazione OAuth2 richiede un Client Secret",
|
||
mqTls: "TLS",
|
||
mqTlsSkipVerify: "Ignora verifica certificato",
|
||
mqPinnedVersion: "Versione fissa",
|
||
mqTokenSigning: "Firma token Broker",
|
||
mqTokenSigningNone: "Non configurato",
|
||
mqTokenSigningKey: "Chiave di firma",
|
||
mqTokenSigningKeyRequired: "La chiave di firma del token Broker è obbligatoria",
|
||
mqTokenSigningKeyPlaceholderHs256: "Broker SECRET",
|
||
mqTokenSigningKeyPlaceholderRs256: "-----BEGIN PRIVATE KEY-----",
|
||
mqTokenSigningHint: "Seleziona in base a jwt.broker.token.mode del broker: SECRET usa HS256, PRIVATE usa RS256. La chiave viene salvata nei secret della connessione.",
|
||
databaseInfo: {
|
||
title: "Informazioni sul database",
|
||
open: "Apri informazioni database {database}",
|
||
copy: "Copia informazioni database",
|
||
sourceConfigured: "Configurazione corrente",
|
||
sourceTested: "Testato",
|
||
configuredDescription: "Mostra prima le informazioni determinabili dal modulo; dopo un test riuscito, vengono aggiunte la versione restituita dal server e i metadati del driver.",
|
||
testedDescription: "Le seguenti informazioni provengono dalla connessione utilizzata per questo test riuscito.",
|
||
productName: "Sistema di gestione database",
|
||
productVersion: "Versione database",
|
||
currentDatabase: "Database corrente",
|
||
serverComment: "Commento server",
|
||
serverCharset: "Set di caratteri del server",
|
||
serverCollation: "Regole di ordinamento del server",
|
||
unquotedIdentifierCase: "Identificatore senza virgolette",
|
||
quotedIdentifierCase: "Identificatore con virgolette",
|
||
driverName: "Driver",
|
||
driverVersion: "Versione driver",
|
||
jdbcVersion: "Versione JDBC",
|
||
identifierCase: {
|
||
lower: "Minuscolo",
|
||
upper: "Maiuscolo",
|
||
mixed: "Misto",
|
||
},
|
||
},
|
||
},
|
||
editor: {
|
||
pressToExecute: "Premi {mod}+Enter per eseguire",
|
||
pressToSaveSql: "Premi {mod}+S per salvare SQL",
|
||
queryTimeoutError: "Timeout della query ({seconds}s). Verifica se la connessione al database è integra.",
|
||
changeQueryTimeout: "Modifica timeout query",
|
||
connectionMayBeLost: "La connessione potrebbe essere andata perduta. Aggiorna i dati e riprova.",
|
||
showResultsPane: "Mostra risultati",
|
||
hideResultsPane: "Nascondi risultati",
|
||
noDatabase: "Nessun database selezionato",
|
||
unsavedChangesTitle: "Modifiche non salvate",
|
||
unsavedChangesMessage: '"{title}" ha modifiche non salvate che andranno perse se chiudi. Salvare prima di chiudere?',
|
||
unsavedChangesBatchCloseMessage: "Alcune schede che stai chiudendo hanno modifiche non salvate che andranno perse. Salvare prima di continuare?",
|
||
unsavedChangesBatchCloseMultipleMessage: '{count} schede SQL che stai chiudendo hanno modifiche non salvate. DBX mostra attualmente "{title}". Salvare prima di continuare?',
|
||
unsavedChangesAppCloseMessage: '"{title}" ha modifiche SQL non salvate che andranno perse se esci da DBX. Salvare prima di uscire?',
|
||
unsavedChangesAppCloseMultipleMessage: '{count} schede SQL hanno modifiche non salvate. DBX mostra attualmente "{title}". Andranno perse se esci da DBX. Salvare prima di uscire?',
|
||
unsavedChangesViewList: "Visualizza {count} schede",
|
||
unsavedChangesListTitle: "Schede non salvate ({count})",
|
||
discardChanges: "Scarta",
|
||
discardAllChanges: "Scarta tutto",
|
||
saveAllChanges: "Salva tutto",
|
||
selectConnection: "Seleziona connessione",
|
||
searchConnection: "Cerca connessioni...",
|
||
selectDatabase: "Seleziona database",
|
||
selectDatabaseRequired: "Seleziona prima un database",
|
||
searchDatabase: "Cerca database...",
|
||
selectSchema: "Seleziona schema",
|
||
searchSchema: "Cerca schemi...",
|
||
setDefaultDatabase: "Imposta Predefinito",
|
||
defaultDatabase: "Predefinito",
|
||
clearDatabase: "Cancella database",
|
||
exPasteNoValues: "Gli appunti non contengono valori per una condizione IN",
|
||
exPasteNotList: "Nessun elenco di più valori convertibile rilevato",
|
||
exPasteTooLarge: "Il contenuto degli appunti è troppo grande. Massimo {limit} caratteri.",
|
||
exPasteTooManyValues: "Troppi valori. Massimo {limit}.",
|
||
exPasteClipboardReadFailed: "Impossibile leggere gli appunti: {message}",
|
||
exPastePasted: "Incollati {count} valori per la condizione IN",
|
||
completion: {
|
||
nullValue: "Valore NULL",
|
||
isNull: "Verifica se NULL",
|
||
isNotNull: "Verifica se non NULL",
|
||
stringLiteral: "Costante stringa",
|
||
numericLiteral: "Costante numerica",
|
||
booleanValue: "Valore booleano",
|
||
starExpansionColumns: "{count} colonne",
|
||
functionDescriptions: {
|
||
COUNT: "Restituisce il numero di righe",
|
||
SUM: "Restituisce la somma di una colonna numerica",
|
||
AVG: "Restituisce la media di una colonna numerica",
|
||
MIN: "Restituisce il valore minimo",
|
||
MAX: "Restituisce il valore massimo",
|
||
GROUP_CONCAT: "Concatena i valori del gruppo in una stringa",
|
||
STRING_AGG: "Concatena le stringhe del gruppo",
|
||
CONCAT: "Concatena più stringhe",
|
||
CONCAT_WS: "Concatena le stringhe con un separatore",
|
||
SUBSTRING: "Estrae una sottostringa",
|
||
REPLACE: "Sostituisce il contenuto in una stringa",
|
||
TRIM: "Rimuove gli spazi iniziali e finali",
|
||
UPPER: "Converte in maiuscolo",
|
||
LOWER: "Converte in minuscolo",
|
||
LENGTH: "Restituisce la lunghezza della stringa",
|
||
REGEXP_REPLACE: "Sostituisce utilizzando un'espressione regolare",
|
||
DATE_FORMAT: "Formatta una data con il formato specificato",
|
||
DATEDIFF: "Calcola la differenza tra due date",
|
||
DATE_ADD: "Aggiunge un intervallo a una data",
|
||
DATE_SUB: "Sottrae un intervallo da una data",
|
||
EXTRACT: "Estrae una parte di data",
|
||
NOW: "Restituisce la data e l'ora correnti",
|
||
ROUND: "Arrotonda alla quantità specificata di decimali",
|
||
FLOOR: "Arrotonda per difetto",
|
||
CEIL: "Arrotonda per eccesso",
|
||
ABS: "Restituisce il valore assoluto",
|
||
MOD: "Restituisce il resto della divisione",
|
||
COALESCE: "Restituisce il primo argomento non NULL",
|
||
IFNULL: "Restituisce un valore sostitutivo se NULL",
|
||
NULLIF: "Restituisce NULL se gli argomenti sono uguali",
|
||
CAST: "Converte un'espressione in un tipo di destinazione",
|
||
JSON_EXTRACT: "Estrae un valore da JSON",
|
||
JSON_VALUE: "Estrae un valore scalare da JSON",
|
||
JSON_OBJECT: "Crea un oggetto JSON",
|
||
JSON_ARRAY: "Crea un array JSON",
|
||
},
|
||
},
|
||
contextMenu: {
|
||
executeSelection: "Esegui selezione",
|
||
executeCurrent: "Esegui SQL",
|
||
copySelection: "Copia selezione",
|
||
sendToAi: "Invia ad AI",
|
||
uppercaseSelection: "Converti in maiuscolo",
|
||
lowercaseSelection: "Converti in minuscolo",
|
||
selectAll: "Seleziona tutto",
|
||
},
|
||
search: {
|
||
find: "Trova",
|
||
replace: "Sostituisci",
|
||
replaceAll: "Sostituisci Tutto",
|
||
caseSensitive: "Maiuscole/Minuscole",
|
||
regex: "Espressione regolare",
|
||
collapseReplace: "Comprimi sostituzione",
|
||
expandReplace: "Espandi sostituzione",
|
||
prevMatch: "Precedente (Shift+Enter)",
|
||
nextMatch: "Successivo (Enter)",
|
||
close: "Chiudi (Esc)",
|
||
noResults: "Nessun risultato",
|
||
},
|
||
executionPicker: {
|
||
title: "Execution Target",
|
||
currentStatement: "Current SQL",
|
||
allStatements: "All SQL",
|
||
currentCommand: "Current command",
|
||
allCommands: "All commands",
|
||
},
|
||
statementExecutionSucceeded: "{count} istruzioni eseguite con successo",
|
||
statementExecutionFailed: "{count} istruzioni fallite",
|
||
},
|
||
tabs: {
|
||
sql: "SQL",
|
||
table: "Tabella",
|
||
tableData: "Dati Tabella",
|
||
redis: "Redis",
|
||
etcd: "etcd",
|
||
zookeeper: "ZooKeeper",
|
||
mongo: "Mongo",
|
||
vector: "Vector",
|
||
objects: "Oggetti",
|
||
users: "Utenti e Privilegi",
|
||
executionSummary: "Riepilogo",
|
||
tooltipTitle: "Titolo:",
|
||
tooltipConnection: "Connessione:",
|
||
tooltipGroup: "Gruppo:",
|
||
tooltipDatabase: "Database:",
|
||
tooltipTable: "Tabella:",
|
||
tooltipCollection: "Collezione:",
|
||
tooltipSchema: "Schema:",
|
||
resultN: "Risultato {n}",
|
||
runN: "Esegui {n}",
|
||
resultRuns: "Esecuzioni risultati",
|
||
removeRun: "Rimuovi esecuzione {n}",
|
||
autoKeepResults: "Mantieni automaticamente i risultati",
|
||
autoKeepResultsEnabled: "Mantieni risultati abilitato",
|
||
autoKeepResultsDisabled: "Mantieni risultati disabilitato",
|
||
autoRefresh: "Aggiorna risultati automaticamente",
|
||
autoRefreshShort: "Auto",
|
||
autoRefreshEvery: "Aggiorna ogni {seconds} s",
|
||
startAutoRefresh: "Avvia aggiornamento automatico",
|
||
stopAutoRefresh: "Ferma aggiornamento automatico",
|
||
missingResultRun: "Questo risultato non e piu disponibile",
|
||
exportResultArchive: "Salva Archivio Risultati",
|
||
importResultArchive: "Importa Archivio Risultati",
|
||
importedResultArchive: "Risultati importati",
|
||
resultArchiveExported: "Risultati esportati",
|
||
resultArchiveImported: "Risultati importati",
|
||
resultArchiveUnavailable: "Nessun risultato salvato disponibile per l'esportazione",
|
||
resultArchiveImportInvalid: "Questo archivio risultati non puo essere aperto",
|
||
resultArchiveExportFailed: "Esportazione risultati non riuscita: {message}",
|
||
resultArchiveImportFailed: "Importazione risultati non riuscita: {message}",
|
||
scrollLeft: "Scorri schede a sinistra",
|
||
scrollRight: "Scorri schede a destra",
|
||
openTabs: "Schede aperte",
|
||
fixedTabs: "Schede bloccate",
|
||
openDataTabs: "Tabelle aperte",
|
||
gridfs: "GridFS",
|
||
},
|
||
executionSummary: {
|
||
empty: "Nessun riepilogo",
|
||
executing: "Esecuzione...",
|
||
statement: "Istruzione",
|
||
type: "Tipo",
|
||
rows: "Righe",
|
||
affected: "Interessate",
|
||
time: "Tempo",
|
||
success: "Riuscita",
|
||
error: "Errore",
|
||
returnedTable: "Restituita una tabella con {count} colonne",
|
||
noTable: "Nessuna tabella restituita",
|
||
},
|
||
chart: {
|
||
title: "Grafico",
|
||
type: "Tipo",
|
||
line: "Linea",
|
||
bar: "Barre",
|
||
pie: "Torta",
|
||
noNumericData: "Nessun dato numerico disponibile per il grafico",
|
||
},
|
||
grid: {
|
||
rows: "{count} righe",
|
||
totalRows: "Totale {count} righe",
|
||
totalRowCount: "({count} in totale)",
|
||
totalRowCountLoading: "(conteggio...)",
|
||
loadingMore: "Caricamento altri dati...",
|
||
allLoaded: "tutto caricato",
|
||
calculateTotalRows: "Conta righe totali",
|
||
calculateTotalRowsInline: "(conta righe totali)",
|
||
calculateTotalRowsFailed: "Conteggio non riuscito: {message}",
|
||
rowsAffected: "{count} righe interessate",
|
||
querySuccess: "Query eseguita con successo",
|
||
noRows: "Nessun dato",
|
||
noRowsDescription: "Questo set di risultati non contiene record.",
|
||
noSearchResults: "Nessuna corrispondenza",
|
||
noSearchResultsDescription: "Prova con un'altra parola chiave.",
|
||
noFilteredRows: "Nessuna riga corrisponde al filtro",
|
||
noFilteredRowsDescription: "Regola il testo di ricerca o il filtro dello stato della riga.",
|
||
copy: "Copia",
|
||
mongoJsonPreview: "Anteprima JSON",
|
||
mongoJsonPreviewEmpty: "Seleziona un documento MongoDB da visualizzare.",
|
||
copyJson: "Copia JSON",
|
||
copyDdl: "Copia DDL",
|
||
copyCell: "Copia Cella",
|
||
copyRow: "Copia Riga (JSON)",
|
||
copyColumnJson: "Copia Colonna (JSON)",
|
||
copyColumnNames: "Copia Nomi Colonne",
|
||
copyRowInsert: "Copia come INSERT",
|
||
copyRowInsertWithoutPrimaryKeys: "Copia come INSERT senza Chiavi Primarie",
|
||
copyRowUpdate: "Copia come UPDATE",
|
||
copyAll: "Copia Tutto (TSV)",
|
||
selection: "Selezione",
|
||
selectionSum: "SUM: {value}",
|
||
selectionCells: "{count} celle",
|
||
copySelectionTsv: "Copia Selezione (TSV)",
|
||
copySelectionTsvWithHeaders: "Copia Selezione con Intestazioni (TSV)",
|
||
copySelectionCsv: "Copia Selezione (CSV)",
|
||
copySelectionJson: "Copia Selezione (JSON)",
|
||
copySelectionSql: "Copia Selezione come elenco SQL IN",
|
||
clearSelection: "Cancella Selezione",
|
||
export: "Esporta",
|
||
exportCsv: "Esporta CSV",
|
||
exportXlsx: "Esporta XLSX",
|
||
exportXlsxWithSql: "Esporta XLSX con SQL",
|
||
exportCurrentPageCsv: "Esporta pagina corrente come CSV",
|
||
exportCurrentPageXlsx: "Esporta pagina corrente come XLSX",
|
||
exportCurrentPageXlsxWithSql: "Esporta pagina corrente come XLSX con SQL",
|
||
exportCurrentPageJson: "Esporta pagina corrente come JSON",
|
||
exportCurrentPageMarkdown: "Esporta pagina corrente come Markdown",
|
||
exportCurrentPageSql: "Esporta pagina corrente come SQL INSERT",
|
||
exportCurrentPageTxt: "Esporta pagina corrente come TXT",
|
||
exportCurrentResultCsv: "Esporta tutti i dati del risultato corrente come CSV",
|
||
exportCurrentResultXlsx: "Esporta tutti i dati del risultato corrente come XLSX",
|
||
exportCurrentResultXlsxWithSql: "Esporta tutti i dati del risultato corrente come XLSX con SQL",
|
||
exportCurrentResultJson: "Esporta tutti i dati del risultato corrente come JSON",
|
||
exportCurrentResultMarkdown: "Esporta tutti i dati del risultato corrente come Markdown",
|
||
exportCurrentResultSql: "Esporta tutti i dati del risultato corrente come SQL INSERT",
|
||
exportCurrentResultTxt: "Esporta tutti i dati del risultato corrente come TXT",
|
||
exportAllResultsXlsx: "Esporta tutti i set di risultati di questa esecuzione come XLSX",
|
||
exportAllResultsXlsxWithSql: "Esporta tutti i set di risultati di questa esecuzione come XLSX con SQL",
|
||
exportJson: "Esporta JSON",
|
||
exportMarkdown: "Esporta Markdown",
|
||
exportSql: "Esporta SQL INSERT",
|
||
exportTxt: "Esporta TXT",
|
||
exportSelectedRowsCsv: "Esporta Righe Selezionate come CSV",
|
||
exportSelectedRowsXlsx: "Esporta Righe Selezionate come XLSX",
|
||
exportSelectedRowsXlsxWithSql: "Esporta Righe Selezionate come XLSX con SQL",
|
||
exportSelectedRowsJson: "Esporta Righe Selezionate come JSON",
|
||
exportSelectedRowsMarkdown: "Esporta Righe Selezionate come Markdown",
|
||
exportSelectedRowsSql: "Esporta Righe Selezionate come SQL INSERT",
|
||
exportSelectedRowsTxt: "Esporta Righe Selezionate come TXT",
|
||
exported: "Esportato",
|
||
exportFailed: "Esportazione non riuscita: {message}",
|
||
copied: "Copiato",
|
||
copyFailed: "Copia non riuscita: {message}",
|
||
previewSqlEmpty: "Nessuna modifica SQL in sospeso da visualizzare",
|
||
renderMode: "Modalità rendering",
|
||
domRenderMode: "DOM",
|
||
canvasRenderMode: "Canvas",
|
||
renderModeHint: "Passa dal rendering Canvas al grid di fallback DOM.",
|
||
tableFontSize: "Dimensione font tabella",
|
||
filter: "Filtra",
|
||
conditionHistoryEmpty: "Nessuna cronologia ancora",
|
||
conditionHistoryNoMatches: "Nessuna corrispondenza nella cronologia",
|
||
filterBuilder: "Filtri",
|
||
filterBuilderTitle: "Filtri",
|
||
filterBuilderHint: "Crea condizioni visive e combinale con l'input WHERE.",
|
||
filterBuilderSummary: "{count} regole",
|
||
filterBuilderAddRule: "Aggiungi regola",
|
||
filterBuilderColumn: "Colonna",
|
||
filterBuilderValue: "Valore",
|
||
filterBuilderValues: "Valori (separati da virgole o nuove righe)",
|
||
filterBuilderRangeStart: "Valore iniziale",
|
||
filterBuilderRangeEnd: "Valore finale",
|
||
filterBuilderNoValue: "Nessun valore richiesto",
|
||
filterBuilderEmpty: "Aggiungi una regola per iniziare a filtrare le righe.",
|
||
resetFilterBuilder: "Reimposta regole",
|
||
filterBuilderEquals: "Uguale a",
|
||
filterBuilderNotEquals: "Diverso da",
|
||
filterBuilderContains: "Contiene",
|
||
filterBuilderNotContains: "Non contiene",
|
||
filterBuilderGreaterThan: "Maggiore di",
|
||
filterBuilderLessThan: "Minore di",
|
||
filterBuilderIn: "Nell'elenco",
|
||
filterBuilderNotIn: "Fuori elenco",
|
||
filterBuilderBetween: "Nell'intervallo",
|
||
filterBuilderNotBetween: "Fuori intervallo",
|
||
filterBuilderIsNull: "È NULL",
|
||
filterBuilderIsNotNull: "Non è NULL",
|
||
columnActions: "Azioni colonna",
|
||
localFilter: "Filtro valori locale",
|
||
localFilterFor: "Valori locali per '{column}'",
|
||
databaseValueFilter: "Filtro valori database",
|
||
databaseValueFilterFor: "Valori database per '{column}'",
|
||
columnFormatter: "Formattatore colonna",
|
||
columnFormatterFor: "Formattatore per '{column}'",
|
||
columnFormatterHint: "Formatta solo la visualizzazione; i valori effettivi rimangono invariati.",
|
||
formatterType: "Tipo",
|
||
formatterDatetime: "Timestamp Unix",
|
||
formatterJsonPath: "Percorso JSON",
|
||
formatterMask: "Maschera testo",
|
||
formatterCustomTemplate: "Modello personalizzato",
|
||
formatterTimestampUnit: "Unità timestamp",
|
||
formatterUnitAuto: "Auto",
|
||
formatterUnitSeconds: "Secondi",
|
||
formatterUnitMilliseconds: "Millisecondi",
|
||
formatterDatetimePattern: "Formato data e orario",
|
||
formatterDatetimePatternPlaceholder: "Seleziona o inserisci un formato data e orario",
|
||
formatterDatetimePatternEmpty: "Formato ISO8601 predefinito",
|
||
formatterJsonPathInput: "Percorso JSON",
|
||
formatterMaskPrefix: "Prefisso visibile",
|
||
formatterMaskSuffix: "Suffisso visibile",
|
||
formatterSavedCustom: "Modelli salvati",
|
||
formatterNewCustom: "Nuovo modello",
|
||
formatterCustomName: "Nome modello",
|
||
formatterCustomNamePlaceholder: "Esempio: Etichetta utente",
|
||
formatterCustomTemplateInput: "Modello",
|
||
formatterCustomTemplateHint: "Variabili disponibili: ${value}, ${upper}, ${lower}, ${length}. Assegna un nome per salvarlo nell'elenco.",
|
||
formatterPreview: "Anteprima",
|
||
saveFormatter: "Salva",
|
||
clearFormatter: "Cancella",
|
||
searchValues: "Cerca valori...",
|
||
loadingValues: "Caricamento valori...",
|
||
serverValuesLimited: "Mostra i primi {count} valori",
|
||
filterTypedValue: "Usa '{value}'",
|
||
value: "Valore",
|
||
count: "Conteggio",
|
||
applyFilter: "Applica Filtro",
|
||
clearLocalFilters: "Cancella filtri valori locali",
|
||
clearLocalFiltersShort: "Cancella locali",
|
||
localFiltersActive: "{count} filtri valori locali",
|
||
localFilterMoreValues: " +{count} altri",
|
||
columnVisibility: "Colonne",
|
||
columnVisibilityHint: "Almeno una colonna deve rimanere visibile.",
|
||
searchColumns: "Cerca colonne...",
|
||
dragColumnToReorder: "Trascina l'intestazione per riordinare",
|
||
invertColumnVisibility: "Inverti",
|
||
resetColumnOrder: "Reimposta ordine",
|
||
showAllColumns: "Mostra tutte",
|
||
viewOptions: "Opzioni visualizzazione",
|
||
hideNullColumns: "Nascondi NULL",
|
||
hideNullColumnsHint: "Nascondi le colonne i cui valori sono tutti NULL nel risultato corrente.",
|
||
moreValues: "altri {count} valori, continua a digitare per restringere i risultati",
|
||
filterByValue: "Filtra per Questo Valore",
|
||
filterExcludeValue: "Escludi Questo Valore",
|
||
filterLike: "Contiene il Valore",
|
||
filterNotLike: "Non Contiene il Valore",
|
||
filterLessThan: "Minore del Valore",
|
||
filterGreaterThan: "Maggiore del Valore",
|
||
filterIsNull: "Mostra Valori NULL",
|
||
filterIsNotNull: "Mostra Valori Non-NULL",
|
||
clearFilter: "Cancella Filtro",
|
||
sort: "Ordina",
|
||
sortAscending: "Ordina in modo crescente",
|
||
sortDescending: "Ordina in modo decrescente",
|
||
sortCurrentPageAscending: "Ordina pagina corrente crescente",
|
||
sortCurrentPageDescending: "Ordina pagina corrente decrescente",
|
||
sortDatabaseAscending: "Ordina database crescente",
|
||
sortDatabaseDescending: "Ordina database decrescente",
|
||
clearSort: "Rimuovi Ordinamento",
|
||
pasted: "Incollato!",
|
||
search: "Cerca...",
|
||
searchOrWhere: "Cerca o inserisci una clausola WHERE...",
|
||
applyWhere: "Applica WHERE",
|
||
filterRows: "Filtra righe",
|
||
filterAllRows: "Tutte le righe",
|
||
filterChangedRows: "Modificate",
|
||
page: "Pagina {page}",
|
||
rowsPerPage: "Righe per pagina",
|
||
customRowsPerPage: "Righe personalizzate",
|
||
applyPageSize: "Applica",
|
||
save: "Salva",
|
||
discard: "Scarta",
|
||
dismiss: "Ignora",
|
||
addRow: "Aggiungi Riga",
|
||
quickEntryDraftPlaceholder: "Nuova",
|
||
cloneRow: "Clona come Nuova Riga",
|
||
deleteRow: "Elimina Riga",
|
||
deleteRows: "Elimina {count} Righe",
|
||
cloneRows: "Clona {count} come Nuove Righe",
|
||
restoreRows: "Ripristina {count} Righe",
|
||
copyRows: "Copia {count} Righe (JSON)",
|
||
copySelectedRowsTsv: "Copia {count} Righe (TSV)",
|
||
copySelectedRowsTsvWithHeaders: "Copia {count} Righe con Intestazioni (TSV)",
|
||
copySelectedRowTsv: "Copia 1 Riga (TSV)",
|
||
copySelectedRowTsvWithHeaders: "Copia 1 Riga con Intestazioni (TSV)",
|
||
copyColumnsJson: "Copia {count} Colonne (JSON)",
|
||
copyRowsInsert: "Copia {count} Righe come INSERT",
|
||
copyRowsInsertMerged: "Copia {count} Righe come INSERT (unito)",
|
||
copyRowsInsertRowByRow: "Copia {count} Righe come INSERT (riga per riga)",
|
||
copyRowsInsertWithoutPrimaryKeys: "Copia {count} Righe come INSERT senza Chiavi Primarie",
|
||
copyRowsInsertWithoutPrimaryKeysMerged: "Copia {count} Righe come INSERT senza Chiavi Primarie (unito)",
|
||
copyRowsInsertWithoutPrimaryKeysRowByRow: "Copia {count} Righe come INSERT senza Chiavi Primarie (riga per riga)",
|
||
copyRowsUpdate: "Copia {count} Righe come UPDATE",
|
||
selectedRows: "{count} righe selezionate",
|
||
restoreRow: "Ripristina Riga",
|
||
statusClean: "Pulito",
|
||
statusNew: "Nuovi Elementi",
|
||
statusEdited: "Elementi Aggiornati",
|
||
statusDeleted: "Elementi Eliminati",
|
||
pendingChanges: "{count} in sospeso",
|
||
selectedCells: "{count} selezionate",
|
||
bulkEditSelection: "Modifica di Massa Selezione",
|
||
bulkEditTitle: "Modifica di Massa Selezione",
|
||
bulkEditDescription: "Imposta le {count} celle selezionate su questo valore.",
|
||
bulkEditValuePlaceholder: "Valore, o NULL",
|
||
applyBulkEdit: "Applica",
|
||
cellDetails: "Dettagli Cella",
|
||
cellDetailLayoutBottom: "Sposta in Basso",
|
||
cellDetailLayoutRight: "Sposta a Destra",
|
||
collapseCellDetailMetadata: "Comprimi metadati cella",
|
||
expandCellDetailMetadata: "Espandi metadati cella",
|
||
openCellDetailsDialog: "Apri Dettagli Cella",
|
||
rowDetails: "Dettagli Riga",
|
||
rowDetailsFor: "Dettagli Riga {row}",
|
||
openRowDetailsDialog: "Apri Dettagli Riga",
|
||
openColumnDetailsDialog: "Apri Dettagli Colonna",
|
||
columnDetailsFor: "Dettagli Colonna {column}",
|
||
columnsCount: "{count} colonne",
|
||
rowCount: "Righe",
|
||
rowsCount: "{count} righe",
|
||
fieldIndex: "N.",
|
||
cellValue: "Valore",
|
||
valueEditor: "Editor dei Valori",
|
||
hexViewer: "Visualizzatore Hex",
|
||
hexViewerByteCount: "{count} byte",
|
||
hexViewerOffset: "Offset",
|
||
hexViewerHex: "Hex",
|
||
hexViewerAscii: "ASCII",
|
||
hexViewerEmpty: "Nessun byte binario da visualizzare.",
|
||
imagePreview: "Anteprima Immagine",
|
||
imageLoadFailed: "Caricamento immagine non riuscito",
|
||
geometryPreview: "Anteprima Geometria",
|
||
layerPreview: "Anteprima Layer",
|
||
zoomIn: "Ingrandisci",
|
||
zoomOut: "Rimpicciolisci",
|
||
fitImage: "Adatta alla Vista",
|
||
openImage: "Apri Immagine",
|
||
columnName: "Colonna",
|
||
columnType: "Tipo",
|
||
columnComment: "Commento",
|
||
rowNumber: "Riga",
|
||
valueLength: "Lunghezza",
|
||
nullValue: "NULL",
|
||
noComment: "Nessun commento",
|
||
formattedJson: "JSON Formattato",
|
||
formattedValue: "Valore Formattato",
|
||
detailSearchPlaceholder: "Cerca campo o valore…",
|
||
detailSearchNoMatch: "Nessun risultato",
|
||
rawValue: "Valore Grezzo",
|
||
largeValuePreviewHint: "Anteprima dei primi {count} caratteri. La copia utilizzerà comunque il valore completo.",
|
||
copyValue: "Copia Valore",
|
||
downloadBinaryValue: "Scarica Valore",
|
||
downloadSaved: "Salvato in {path}",
|
||
downloadStarted: "Download avviato: {fileName}",
|
||
binaryDownload: {
|
||
binary: "Binario grezzo",
|
||
utf8: "Testo decodificato (UTF-8)",
|
||
gbk: "Testo decodificato (GBK)",
|
||
},
|
||
copyRowTsv: "Copia Riga (TSV)",
|
||
copyColumnValues: "Copia Colonna (JSON)",
|
||
copyColumnTsv: "Copia Colonna (TSV)",
|
||
editValue: "Modifica Valore",
|
||
formatJson: "Formatta JSON",
|
||
compactJson: "Compatta JSON",
|
||
formattedJsonEditWarning: "Stai modificando JSON formattato. Salvando verrà scritto come JSON, quindi la formattazione originale potrebbe cambiare.",
|
||
setNull: "Imposta NULL",
|
||
restoreOriginalValue: "Ripristina Originale",
|
||
copyColumnName: "Copia Nome Colonna",
|
||
copyAlterColumnSql: "Copia come SQL ALTER",
|
||
alterSqlCopied: "SQL ALTER copiato negli appunti",
|
||
alterSqlCopiedWithWarnings: "SQL ALTER copiato negli appunti ({count} avviso/i)",
|
||
noAlterSqlAvailable: "Nessun SQL ALTER disponibile per questa colonna",
|
||
copyAlterSqlFailed: "Copia non riuscita: {message}",
|
||
copySqlCondition: "Copia Condizione SQL",
|
||
transpose: "Traspone Riga",
|
||
transposeMultiRowToggle: "Più righe",
|
||
transposeSingleRow: "Riga corrente",
|
||
transposeMultiRow: "Più righe",
|
||
transposeMultiRowHint: "Quando è attiva, la vista trasposta mostra più righe. Quando è disattiva, mostra solo la riga corrente.",
|
||
rowsPerPageShort: " righe",
|
||
columnDetails: "Dettagli Colonna",
|
||
tableInfo: "Informazioni Tabella",
|
||
tableInfoColumns: "Colonne",
|
||
tableInfoIndexes: "Indici",
|
||
tableInfoForeignKeys: "Chiavi Esterne",
|
||
tableInfoTriggers: "Trigger",
|
||
tableInfoNullable: "Nullabile",
|
||
tableInfoEmpty: "Nessun metadato",
|
||
tableInfoSearch: "Cerca...",
|
||
tableInfoNoResults: "Nessun risultato",
|
||
goToColumn: "Vai alla colonna",
|
||
columnWidth: "Larghezza colonna",
|
||
columnWidthCompact: "Compatto",
|
||
columnWidthStandard: "Standard",
|
||
columnWidthComfortable: "Ampio",
|
||
searchColumn: "Cerca colonna/commento...",
|
||
noColumnsFound: "Nessuna colonna trovata",
|
||
queryError: "Errore Query",
|
||
dataUnavailable: "I dati della tabella devono essere ricaricati.",
|
||
dataUnavailableHintPrefix: "Premi ",
|
||
dataUnavailableHintSuffix: " o fai clic su Aggiorna qui sotto per ricaricare.",
|
||
refresh: "Aggiorna",
|
||
undoChange: "Annulla modifica",
|
||
redoChange: "Ripeti modifica",
|
||
commit: "Commit",
|
||
rollback: "Rollback",
|
||
transactionSaveHint: "Applica {count} modifica/he in sospeso in una transazione.",
|
||
nonTransactionalSaveHint: "Salva {count} modifica/he in sospeso una ad una. In caso di errore, le modifiche salvate in precedenza non saranno annullate.",
|
||
keylessEditWarning: "Nessuna chiave primaria",
|
||
keylessEditWarningHint: "Questa tabella non ha chiavi primarie. Gli aggiornamenti e le eliminazioni utilizzano tutti i valori originali delle righe nella clausola WHERE; le righe duplicate esatte potrebbero essere influenzate contemporaneamente.",
|
||
queryEditReadOnly: "Risultato in sola lettura",
|
||
queryEditUnsupported: {
|
||
"not-select": "Only SELECT query results can be edited directly.",
|
||
cte: "Le query con WITH/CTE non sono ancora modificabili. Usa una semplice SELECT a tabella singola.",
|
||
"set-operation": "UNION, INTERSECT, or EXCEPT results cannot be mapped safely back to source rows.",
|
||
aggregation: "I risultati di DISTINCT, GROUP BY, HAVING e aggregazioni non possono essere modificati direttamente.",
|
||
"external-source": "External files and table-function results cannot be written back directly. Import them into a database table before editing.",
|
||
"complex-source": "DBX could not identify exactly one safe writeback target table for this result.",
|
||
"computed-columns": "Computed expressions or function results cannot be written back. Select raw column names instead.",
|
||
"no-table": "No editable source table was detected.",
|
||
"no-primary-key": "The target table has no primary key, so rows cannot be updated or deleted safely.",
|
||
"primary-key-not-returned": "The result is missing the raw primary key column. Include it by its original column name.",
|
||
"aliased-columns": "Result columns use aliases or expressions. Select editable columns by their original names.",
|
||
"metadata-unavailable": "DBX could not load table metadata, so result editing is disabled.",
|
||
},
|
||
sortUnsupported: "Questo SQL non supporta l'ordinamento sull'intero risultato. Riprova con una query SELECT semplice.",
|
||
truncatedHint: "Risultati troncati a {count} righe. Usa la paginazione a piè di pagina o regola le righe per pagina.",
|
||
filterBuilderSearchColumns: "Cerca campi...",
|
||
filterBuilderNoMatchingColumns: "Nessun campo corrispondente",
|
||
},
|
||
exportProgress: {
|
||
title: "Esportazione Dati Tabella",
|
||
fetching: "Recupero dati dal database...",
|
||
writing: "Scrittura su file...",
|
||
done: "Esportazione completata!",
|
||
error: "Esportazione non riuscita",
|
||
cancelled: "Esportazione annullata.",
|
||
rowsCount: "{exported} / {total} righe",
|
||
rowsExported: "{count} righe esportate",
|
||
rowsShort: "righe",
|
||
cancel: "Annulla",
|
||
openFolder: "Apri cartella contenente",
|
||
openFolderFailed: "Impossibile aprire la cartella: {message}",
|
||
close: "Chiudi",
|
||
tooltip: "Stato Esportazione",
|
||
failedTooltip: "{count} attività in background non riuscita | {count} attività in background non riuscite",
|
||
popoverTitle: "Esportazioni",
|
||
noTasks: "Nessuna esportazione",
|
||
clearFinished: "Cancella completate",
|
||
showMore: "Mostra altri {count}",
|
||
showLess: "Mostra meno",
|
||
delete: "Rimuovi",
|
||
databaseExportTitle: "Backup database: {name}",
|
||
sqlFileTitle: "File SQL: {name}",
|
||
dataTransferTitle: "Trasferimento dati: {name}",
|
||
objectsCount: "{current} / {total} oggetti",
|
||
tablesCount: "{current} / {total} tabelle",
|
||
statementsCount: "{done} riuscite, {failed} non riuscite",
|
||
},
|
||
welcome: {
|
||
title: "Area di Lavoro Database",
|
||
subtitle: "Scegli una connessione a sinistra per esplorare lo schema, oppure apri direttamente una scheda query.",
|
||
connections: "Connessioni",
|
||
connected: "Connesso",
|
||
databaseTypes: "Tipi Database",
|
||
quickConnections: "Avvio Rapido",
|
||
quickConnectionsHint: "Fai clic su una connessione per aprire una scheda query.",
|
||
shortcuts: "Scorciatoie",
|
||
shortcutsHint: "Avvia la prossima azione da qui.",
|
||
sqlHistory: "Cronologia Query",
|
||
sqlHistoryEmpty: "Nessun record nella Libreria SQL",
|
||
sqlHistoryOpenCount: "Aperto {count} volte",
|
||
unknownConnection: "Connessione sconosciuta",
|
||
tip: "Puoi anche espandere le connessioni a sinistra e fare clic con il tasto destro su database o tabelle per altre azioni.",
|
||
tipSidebar: "Fai clic su una tabella a sinistra per visualizzarne i dati",
|
||
tipExecute: "per eseguire la query",
|
||
fileOpened: "Aperto {name}",
|
||
mcpTitle: "Integrazione Agente AI",
|
||
mcpDescription: "Oltre all'assistente AI integrato, puoi utilizzare Claude Code, Cursor e altri agenti di sviluppo per interrogare i tuoi database tramite MCP.",
|
||
mcpLearnMore: "Scopri di più",
|
||
},
|
||
common: {
|
||
language: "Lingua",
|
||
loading: "Caricamento...",
|
||
stopping: "Interruzione...",
|
||
close: "Chiudi",
|
||
cancel: "Annulla",
|
||
save: "Salva",
|
||
copy: "Copia",
|
||
import: "Importa",
|
||
remove: "Rimuovi",
|
||
retry: "Riprova",
|
||
more: "Altro",
|
||
decrease: "Riduci",
|
||
increase: "Aumenta",
|
||
showPassword: "Mostra password",
|
||
hidePassword: "Nascondi password",
|
||
done: "Fatto",
|
||
connection: "Connessione",
|
||
database: "Database",
|
||
table: "Tabella",
|
||
view: "Vista",
|
||
materializedView: "Vista Materializzata",
|
||
procedure: "Procedura",
|
||
function: "Funzione",
|
||
sequence: "Sequenza",
|
||
package: "Pacchetto",
|
||
packageBody: "Corpo Pacchetto",
|
||
noResults: "Nessun risultato",
|
||
edit: "Modifica",
|
||
delete: "Elimina",
|
||
back: "Indietro",
|
||
},
|
||
quickOpen: {
|
||
placeholder: "Cerca connessioni, database, tabelle e altri oggetti...",
|
||
emptyPlaceholder: "Inizia a digitare per cercare",
|
||
noResults: "Nessun risultato trovato",
|
||
results: "risultati",
|
||
navigate: "Naviga",
|
||
select: "Seleziona",
|
||
close: "Chiudi",
|
||
},
|
||
explain: {
|
||
title: "Piano di Spiegazione",
|
||
standardTable: "Tabella",
|
||
tree: "Albero",
|
||
summary: "Riepilogo",
|
||
running: "Lettura del piano di spiegazione...",
|
||
empty: "Nessun piano di spiegazione",
|
||
nodeCount: "{count} nodi",
|
||
node: "Nodo",
|
||
relation: "Tabella",
|
||
index: "Indice",
|
||
cost: "Costo",
|
||
rows: "Righe",
|
||
details: "Dettagli",
|
||
unsupported: "Il piano di spiegazione non è ancora supportato per questo database",
|
||
emptySql: "Nessun SQL da spiegare",
|
||
unsafe: "Questa prima versione spiega solo istruzioni SELECT / WITH / TABLE / VALUES",
|
||
},
|
||
lineage: {
|
||
title: "Lineage dei Campi",
|
||
open: "Visualizza Lineage dei Campi",
|
||
loading: "Lettura metadati in corso {done}/{total}",
|
||
empty: "Nessun lineage correlato trovato",
|
||
noFiltered: "Nessun risultato corrisponde ai filtri correnti",
|
||
targetField: "Campo Corrente",
|
||
searchPlaceholder: "Cerca tabelle, campi, viste o frammenti SQL...",
|
||
showing: "Mostrati {shown}/{total} risultati",
|
||
all: "Tutti",
|
||
certain: "Sicuro",
|
||
likely: "Probabile",
|
||
possible: "Possibile",
|
||
queryHistory: "Cronologia Query",
|
||
openTable: "Apri tabella",
|
||
copy: "Copia nome",
|
||
copied: "Copiato",
|
||
kind: {
|
||
foreignKey: "Chiave Esterna",
|
||
viewReference: "Vista",
|
||
historyReference: "Cronologia SQL",
|
||
sameName: "Stesso Nome",
|
||
},
|
||
description: {
|
||
foreignKeyIncoming: "{target} punta al campo corrente tramite una chiave esterna. Si tratta di una dipendenza verificata.",
|
||
foreignKeyOutgoing: "Il campo corrente fa riferimento a {target} tramite una chiave esterna. Si tratta di una dipendenza verificata.",
|
||
viewLikely: "La definizione della vista menziona sia la tabella che il campo di destinazione, indicando solitamente una dipendenza della query.",
|
||
viewPossible: "La definizione della vista menziona un campo con lo stesso nome ma non la tabella di destinazione, pertanto richiede conferma.",
|
||
historyLikely: "Un'istruzione SQL della cronologia menziona sia la tabella che il campo di destinazione. Utilizzalo come contesto per l'analisi dell'impatto.",
|
||
historyPossible: "Un'istruzione SQL della cronologia menziona un campo con lo stesso nome. Potrebbe essere correlata, ma necessita di contesto.",
|
||
sameName: "Un'altra tabella ha un campo con lo stesso nome. Potrebbe condividere il significato aziendale ma non è una dipendenza verificata del database.",
|
||
},
|
||
cancel: "Annulla",
|
||
refresh: "Analizza di Nuovo",
|
||
},
|
||
connectionGroup: {
|
||
createGroup: "Nuovo Gruppo",
|
||
groupNamePlaceholder: "Nome gruppo",
|
||
renameGroup: "Rinomina Gruppo",
|
||
deleteGroup: "Elimina Gruppo",
|
||
moveToGroup: "Sposta nel Gruppo",
|
||
moveToNewGroup: "Sposta in un Nuovo Gruppo",
|
||
ungrouped: "Non raggruppati",
|
||
ungroupedLabel: "Non raggruppati",
|
||
newGroup: "Nuovo Gruppo...",
|
||
newGroupDefault: "Nuovo Gruppo",
|
||
deleteGroupConfirmTitle: "Elimina Gruppo",
|
||
deleteGroupConfirmMessage: 'Eliminare il gruppo "{name}"? Le connessioni al suo interno verranno spostate al livello principale.',
|
||
selectConnection: "Seleziona connessione",
|
||
deselectConnection: "Deseleziona connessione",
|
||
selectAllConnections: "Seleziona tutte le connessioni",
|
||
deselectAllConnections: "Deseleziona tutte le connessioni",
|
||
exitMultiSelect: "Esci dalla selezione multipla",
|
||
},
|
||
databaseSearch: {
|
||
title: "Cerca nel Database",
|
||
open: "Cerca nel Database",
|
||
keyword: "Parola chiave",
|
||
keywordPlaceholder: "Inserisci un ID utente, un'email, un numero d'ordine...",
|
||
limitPerTable: "Per tabella",
|
||
search: "Cerca",
|
||
searching: "Ricerca in corso",
|
||
stop: "Interrompi",
|
||
hint: "Scansiona le tabelle normali nel database o schema corrente. Le colonne binarie vengono saltate e ciascuna tabella è limitata per evitare il caricamento simultaneo di troppi dati.",
|
||
loadingTables: "Lettura dell'elenco delle tabelle...",
|
||
progress: "Scansionate {done}/{total} tabelle",
|
||
resultCount: "{count} corrispondenze",
|
||
limitedTables: "Rilevato schema di grandi dimensioni; vengono scansionate solo le prime {count} tabelle",
|
||
results: "Risultati",
|
||
openResult: "Apri",
|
||
waiting: "In attesa di corrispondenze...",
|
||
noResults: "Nessuna corrispondenza finora",
|
||
errors: "Alcune tabelle non sono riuscite",
|
||
},
|
||
configExport: {
|
||
passphraseTitle: "Crittografa ed Esporta",
|
||
passphraseImportTitle: "Decrittografa e Importa",
|
||
passphraseExportHint: "Per includere le password di connessione nell'esportazione, imposta una passphrase per la crittografia. Avrai bisogno della stessa passphrase per importare.",
|
||
passphraseImportHint: "Questo file è crittografato. Inserisci la passphrase per decrittografarlo e importarlo.",
|
||
passphrase: "Passphrase",
|
||
passphraseConfirm: "Conferma Passphrase",
|
||
passphrasePlaceholder: "Inserisci passphrase",
|
||
passphraseConfirmPlaceholder: "Re-inserisci passphrase",
|
||
passphraseRequired: "La passphrase è richiesta",
|
||
passphraseMismatch: "Le passphrase non corrispondono",
|
||
passphraseTooShort: "La passphrase deve essere di almeno 4 caratteri",
|
||
exportEncrypted: "Esporta",
|
||
decryptImport: "Decrittografa e Importa",
|
||
wrongPassphrase: "Passphrase errata o file corrotto",
|
||
cryptoUnavailable: "L'importazione cifrata non è disponibile in questo contesto del browser. Usa HTTPS, localhost o DBX Desktop.",
|
||
exportSuccess: "Connessioni esportate con successo",
|
||
importSuccess: "Importata/e {count} connessione/i",
|
||
importNavicatSuccess: "Importata/e {count} connessione/i Navicat. Inserisci le password mancanti prima di testare la connessione.",
|
||
importDatagripSuccess: "Importate {count} connessione/i DataGrip, riempite {filled} password dalla Keychain.",
|
||
importDbeaverSuccess: "Importata/e {count} connessione/i DBeaver. Inserisci le password mancanti prima di testare la connessione.",
|
||
importNone: "Nessuna nuova connessione da importare",
|
||
importLayoutConfirm: "Il file importato contiene gruppi di connessioni. Vuoi applicarli?",
|
||
importLayoutTitle: "Importa Gruppi",
|
||
importLayoutApply: "Applica",
|
||
},
|
||
ai: {
|
||
placeholder: "Descrivi la tua query in linguaggio naturale...",
|
||
settings: "Impostazioni AI",
|
||
noConfig: "L'AI non è configurata. Configura il tuo provider AI in Impostazioni > AI.",
|
||
provider: "Provider",
|
||
providerStatusActive: "Attivo",
|
||
providerStatusConfigured: "Configurato",
|
||
switchProvider: "Cambia provider",
|
||
model: "Modello",
|
||
defaultModel: "Modello predefinito",
|
||
browseModels: "Sfoglia modelli",
|
||
refreshModels: "Aggiorna modelli",
|
||
loadingModels: "Caricamento modelli...",
|
||
searchModels: "Cerca modelli",
|
||
noModels: "Nessun modello caricato",
|
||
selectModel: "Seleziona modello",
|
||
noModel: "Nessun modello configurato",
|
||
configNameEmpty: "Il nome della configurazione non può essere vuoto",
|
||
configNameExists: "Il nome della configurazione '{name}' esiste già",
|
||
|
||
configList: "Lista configurazioni AI",
|
||
addConfig: "Aggiungi configurazione",
|
||
noAiConfigs: "Nessuna configurazione AI",
|
||
setDefault: "Imposta come predefinita",
|
||
editConfig: "Modifica configurazione",
|
||
configName: "Nome configurazione",
|
||
configNamePlaceholder: "Inserisci nome",
|
||
modelList: "Lista modelli",
|
||
modelId: "ID modello",
|
||
modelDisplayName: "Nome visualizzato",
|
||
add: "Aggiungi",
|
||
fetching: "Recupero...",
|
||
fetchModelList: "Recupera modelli dall'API",
|
||
default: "Predefinita",
|
||
deleteConfigTitle: "Elimina configurazione",
|
||
deleteConfigConfirm: "Eliminare questa configurazione?",
|
||
modelListHint: "Fai clic su aggiorna per caricare i modelli dal provider.",
|
||
modelListUnsupported: "Questo provider non supporta il recupero di un elenco di modelli.",
|
||
modelListEndpointRequired: "Inserisci un endpoint prima di caricare i modelli.",
|
||
modelListApiKeyRequired: "Inserisci una chiave API prima di caricare i modelli.",
|
||
run: "Esegui",
|
||
readingSchema: "Lettura schema",
|
||
noConnection: "Nessuna connessione disponibile per questa scheda",
|
||
noSql: "Nessun SQL da elaborare",
|
||
sqlPreview: "Anteprima SQL",
|
||
copySql: "Copia SQL",
|
||
copyCode: "Copia Codice",
|
||
executeSql: "Esegui SQL",
|
||
tempRunSql: "Esegui senza modificare",
|
||
copyAll: "Copia Tutto",
|
||
copied: "Copiato",
|
||
copyTestResult: "Copia risultato test",
|
||
replace: "Sostituisci Editor",
|
||
append: "Accoda all'Editor",
|
||
apply: "Applica all'Editor",
|
||
clear: "Cancella Chat",
|
||
welcome: "Dimmi cosa vorresti interrogare e io scriverò il codice SQL",
|
||
newChat: "Nuova Chat",
|
||
thinking: "Riflessione...",
|
||
reasoningProcess: "Processo di riflessione",
|
||
chars: "car.",
|
||
stopGenerating: "Interrompi generazione",
|
||
scrollToBottom: "Torna in fondo",
|
||
tableMentionEmpty: "Nessuna tabella o file SQL corrispondente",
|
||
tableMentionPlaceholderHint: "Digita {'@'} per menzionare tabelle o file SQL per il contesto",
|
||
tableMentionTypes: {
|
||
table: "Tabella",
|
||
view: "Vista",
|
||
systemTable: "Tabella di sistema",
|
||
temporaryTable: "Tabella temporanea",
|
||
},
|
||
modes: {
|
||
ask: "Chiedi",
|
||
agent: "Agente",
|
||
},
|
||
modeHints: {
|
||
ask: "Genera SQL e spiegazioni senza eseguirli automaticamente",
|
||
agent: "Esegui automaticamente le query sicure quando possibile",
|
||
},
|
||
fixWithAi: "Correggi con AI",
|
||
truncated: "Contesto troncato",
|
||
contextSummary: "{database} · {tables} tabelle",
|
||
autoSqlBlocked: "L'SQL generato dall'AI è sembrato troppo rischioso per l'esecuzione automatica. Rivedilo manualmente prima di eseguirlo.",
|
||
proposalConfirmYes: "Sì, procedi",
|
||
proposalConfirmNo: "No, grazie",
|
||
proposalConfirmTitle: "Conferma azione richiesta",
|
||
agentSteps: {
|
||
generated: "SQL generato",
|
||
noSql: "Nessun SQL trovato",
|
||
safe: "Sicurezza superata",
|
||
needsConfirm: "Richiede conferma",
|
||
blocked: "Bloccato",
|
||
autoExecute: "Pronto per l'esecuzione",
|
||
notRequested: "Esecuzione non richiesta",
|
||
skipped: "Non eseguito",
|
||
callingTool: "Chiamata strumento...",
|
||
toolDone: "Strumento completato",
|
||
toolError: "Errore strumento",
|
||
executeSafe: "Controllo di sicurezza superato · Eseguito",
|
||
executeBlocked: "Bloccato dal controllo di sicurezza",
|
||
contextCompacted: "Contesto compresso",
|
||
},
|
||
agentStepTitles: {
|
||
riskCheck: "Controllo rischi: {action} · {category} · {environment} · {reasons}",
|
||
blocked: "L'esecuzione è stata bloccata dalla politica dei rischi. Rivedi l'SQL manualmente.",
|
||
requiresConfirmation: "Questo SQL richiede una conferma prima dell'esecuzione.",
|
||
askMode: "La modalità Chiedi non esegue automaticamente l'SQL.",
|
||
unsupportedAction: "L'azione AI corrente non esegue automaticamente l'SQL.",
|
||
noSql: "La risposta non includeva un blocco di codice SQL eseguibile.",
|
||
notRequested: "L'utente non ha richiesto l'esecuzione dell'SQL.",
|
||
skipped: "Questo passaggio non è stato eseguito.",
|
||
},
|
||
proxy: "Proxy",
|
||
proxyEnable: "Invia richieste AI tramite proxy",
|
||
proxyUrl: "URL Proxy",
|
||
enableThinking: "Pensiero (Thinking)",
|
||
enableThinkingOn: "Abilitato",
|
||
enableThinkingOff: "Disabilitato",
|
||
enableThinkingHint: "Questa opzione ha effetto solo sulle API /chat/completions e sui modelli supportati. Quando è disabilitata, può ridurre notevolmente l'uso dei token, ma la qualità dei risultati generati potrebbe diminuire leggermente.",
|
||
anthropicMessagesHint: "Le API compatibili con Anthropic Messages di solito usano /v1/messages.",
|
||
contextWindow: "Finestra di Contesto",
|
||
contextWindowAuto: "Auto (rileva dal nome del modello)",
|
||
contextWindowHint: "Token. Lascia vuoto per il rilevamento automatico. Imposta manualmente per modelli locali/personalizzati.",
|
||
codexCliPath: "Percorso Codex CLI",
|
||
codexCliPathHint: "Lascia vuoto per usare codex dal PATH. Esegui login separatamente con codex login.",
|
||
codexCliPathEnvError: "Codex CLI Path deve contenere solo il percorso dell'eseguibile. Aggiungi le variabili d'ambiente sotto.",
|
||
codexCliEnv: "Variabili d'ambiente",
|
||
codexCliEnvAdd: "Aggiungi variabile",
|
||
codexCliEnvHint: "Variabili opzionali passate a Codex CLI, come HTTPS_PROXY, NO_PROXY, SSL_CERT_FILE o CODEX_CA_CERTIFICATE.",
|
||
codexCliEnvKeyPlaceholder: "HTTPS_PROXY",
|
||
codexCliEnvValuePlaceholder: "http://proxy:9800",
|
||
codexCliEnvInvalidName: "Nome variabile d'ambiente non valido: {name}",
|
||
codexCliEnvReservedName: "{name} è gestita da DBX per MCP Server e non può essere impostata qui.",
|
||
codexMcpRequiredTitle: "DBX MCP Server richiesto",
|
||
codexMcpRequiredDescription: "Codex CLI usa il DBX MCP Server per accedere allo schema del database e agli strumenti di query. Installalo prima di usare Codex nell'assistente AI.",
|
||
reasoningLevel: "Livello di ragionamento",
|
||
reasoningLevelDefault: "Predefinito",
|
||
reasoningLevelMinimal: "Minimo",
|
||
reasoningLevelLow: "Basso",
|
||
reasoningLevelMedium: "Medio",
|
||
reasoningLevelHigh: "Alto",
|
||
reasoningLevelHint: "Controlla model_reasoning_effort di Codex CLI. Predefinito usa la configurazione Codex.",
|
||
actions: {
|
||
general: "Generale",
|
||
generate: "Genera SQL",
|
||
explain: "Spiega SQL",
|
||
optimize: "Ottimizza SQL",
|
||
fix: "Correggi Errore",
|
||
convert: "Converti Dialetto",
|
||
sampleData: "Dati di Esempio",
|
||
query: "Interroga dati",
|
||
exploreSchema: "Ispeziona schema",
|
||
executeAndExplain: "Esegui e spiega",
|
||
generateNoExec: "Genera (senza eseguire)",
|
||
},
|
||
placeholders: {
|
||
general: "Chiedi qualsiasi cosa...",
|
||
generate: "Descrivi cosa desideri interrogare, es. ordini per utente negli ultimi 7 giorni",
|
||
explain: "Opzionale: aggiungi cosa desideri comprendere",
|
||
optimize: "Opzionale: aggiungi un obiettivo, es. ridurre le scansioni complete della tabella",
|
||
fix: "Incolla l'errore o descrivi il risultato atteso",
|
||
convert: "es. converti in PostgreSQL / MySQL / SQL Server",
|
||
sampleData: "Descrivi i dati di esempio o le istruzioni di test da generare",
|
||
query: "Descrivi cosa interrogare o conteggiare, es. totali ordini per regione questo mese",
|
||
exploreSchema: "Descrivi la tabella o struttura da ispezionare, es. colonne e indici di orders",
|
||
executeAndExplain: "Opzionale: aggiungi su cosa concentrare la spiegazione",
|
||
},
|
||
editMessage: "Modifica messaggio",
|
||
editResend: "Invia di nuovo",
|
||
editCancel: "Annulla",
|
||
cannotDeleteActiveConfig: "Non è possibile eliminare la configurazione attualmente attiva. Passa a un'altra configurazione prima.",
|
||
},
|
||
contextMenu: {
|
||
openConnection: "Apri Connessione",
|
||
closeConnection: "Chiudi Connessione",
|
||
closeDatabaseConnection: "Chiudi Connessione Database",
|
||
deleteConnection: "Elimina Connessione",
|
||
deleteSelectedConnections: "Elimina {count} connessioni selezionate",
|
||
confirmDeleteTitle: "Elimina Connessione",
|
||
confirmDeleteMessage: 'Sei sicuro di voler eliminare "{name}"? Questa azione non può essere annullata.',
|
||
confirmDeleteSelectedMessage: "Eliminare le {count} connessioni selezionate? Questa azione non può essere annullata.",
|
||
editConnection: "Modifica Connessione",
|
||
revealDatabaseFile: "Mostra nel file manager",
|
||
selectVisibleDatabases: "Seleziona Database Visibili",
|
||
configureVisibleObjects: "Filtro Oggetti Visibili",
|
||
userAdmin: "Utenti e Privilegi",
|
||
openUserAdmin: "Apri Utenti e Privilegi",
|
||
damengJobAdmin: "Job agente Dameng",
|
||
openDamengJobAdmin: "Apri job agente Dameng",
|
||
duplicateConnection: "Duplica Connessione",
|
||
duplicateSelectedConnections: "Duplica {count} connessioni selezionate",
|
||
newQuery: "Nuova Query",
|
||
instanceInfo: "Informazioni Istanza",
|
||
newSql: "Nuovo SQL",
|
||
generateSql: "Genera SQL",
|
||
newInsert: "Nuovo Insert",
|
||
newUpdate: "Nuovo Update",
|
||
sqlHistory: "Cronologia Query",
|
||
noSqlHistory: "Nessun SQL correlato",
|
||
openObjectBrowser: "Esplora Oggetti",
|
||
viewData: "Visualizza Dati",
|
||
openInNewDataTab: "Visualizza in nuova scheda",
|
||
editStructure: "Modifica Struttura",
|
||
editColumn: "Modifica Colonna",
|
||
editIndex: "Modifica Indice",
|
||
refreshChildren: "Aggiorna",
|
||
expandAll: "Espandi tutto",
|
||
pin: "Fissa",
|
||
unpin: "Sblocca",
|
||
fixTab: "Blocca scheda",
|
||
unfixTab: "Sblocca scheda",
|
||
refreshTab: "Aggiorna Dati",
|
||
renameTab: "Rinomina Scheda",
|
||
duplicateTab: "Duplica Scheda",
|
||
compactTabTitle: "Accorcia Titoli Schede",
|
||
fullTabTitle: "Mostra titoli completi delle schede",
|
||
closeTab: "Chiudi Scheda",
|
||
closeFixedTab: "Chiudi Scheda Fissa",
|
||
closeOtherTabs: "Chiudi Altre Schede",
|
||
closeOtherRegularTabs: "Chiudi Altre Schede Normali",
|
||
closeOtherFixedTabs: "Chiudi Altre Schede Fisse",
|
||
closeAllTabs: "Chiudi Tutte le Schede",
|
||
closeAllRegularTabs: "Chiudi Tutte le Schede Normali",
|
||
closeAllFixedTabs: "Chiudi Tutte le Schede Fisse",
|
||
copyName: "Copia Nome",
|
||
copyFinalProxyPort: "Copia porta proxy finale",
|
||
finalProxyPortCopied: "Porta proxy finale {port} copiata",
|
||
setDefaultDatabase: "Imposta come Database Predefinito",
|
||
clearDefaultDatabase: "Cancella Database Predefinito",
|
||
exportDatabase: "Esporta Database",
|
||
exportAllDatabases: "Esporta tutti i database",
|
||
exportDatabaseSuccess: "Esportate {count} tabelle, fino a {limit} righe ciascuna",
|
||
exportDatabaseFailed: "Impossibile esportare il database: {message}",
|
||
backupSqliteDatabase: "Backup SQLite Database",
|
||
backupSqliteDatabaseInProgress: "Backing up SQLite database...",
|
||
backupSqliteDatabaseSuccess: "SQLite database backed up",
|
||
backupSqliteDatabaseFailed: "Failed to backup SQLite database: {message}",
|
||
importData: "Importa Dati",
|
||
exportData: "Esporta Dati",
|
||
exportStructure: "Esporta Struttura",
|
||
exportStructurePreviewTitle: "Struttura - {name}",
|
||
exportStructurePreviewTitleMultiple: "Struttura - {count} oggetti",
|
||
exportStructureLoading: "Caricamento struttura...",
|
||
copyStructure: "Copia Struttura",
|
||
copyStructureAs: "Copia Struttura Come",
|
||
copyStructureAsTsv: "TSV (per Excel)",
|
||
copyStructureAsMarkdown: "Tabella Markdown",
|
||
structureDocTable: "Tabella",
|
||
structureDocColumn: "Colonna",
|
||
structureDocType: "Tipo",
|
||
structureDocPrimaryKey: "Chiave Primaria",
|
||
structureDocNullable: "Nullabile",
|
||
structureDocDefault: "Predefinito",
|
||
structureDocComment: "Commento",
|
||
structureDocYes: "Sì",
|
||
structureDocNo: "No",
|
||
structureDocCopied: "Struttura copiata",
|
||
structureDocCopyFallbackHint: "La copia automatica è stata bloccata. Fai di nuovo clic su Copia o seleziona il contenuto di seguito.",
|
||
saveStructure: "Salva SQL",
|
||
exportStructureCopied: "Struttura copiata",
|
||
createTable: "Crea Tabella",
|
||
createView: "Crea Vista",
|
||
dropTable: "Elimina Tabella (DROP)",
|
||
emptyTable: "Svuota Tabella",
|
||
truncateTable: "Tronca Tabella (TRUNCATE)",
|
||
duplicateStructure: "Clona come Nuova Tabella",
|
||
renameObject: "Rinomina",
|
||
renameObjectTitle: "Rinomina Oggetto",
|
||
renameObjectNamePlaceholder: "Nuovo nome",
|
||
renameObjectSuccess: '"{oldName}" rinominato in "{newName}"',
|
||
confirmDropTableTitle: "Elimina Tabella",
|
||
confirmDropTableMessage: 'Sei sicuro di voler eliminare (DROP) la tabella "{name}"? Questa operazione eliminerà permanentemente la tabella e tutti i suoi dati.',
|
||
dropTableCascade: "Usa CASCADE",
|
||
dropTableCascadeHint: "Elimina anche gli oggetti dipendenti, come le viste. Lascia disattivato per usare il comportamento RESTRICT predefinito di PostgreSQL.",
|
||
truncateTableCascade: "Usa CASCADE",
|
||
truncateTableCascadeHint: "Tronca anche le tabelle che fanno riferimento a questa tabella tramite chiavi esterne. Lascia disattivato per usare il comportamento RESTRICT predefinito di PostgreSQL.",
|
||
confirmEmptyTableTitle: "Svuota Tabella",
|
||
confirmEmptyTableMessage: 'Sei sicuro di voler eliminare tutti i dati da "{name}"?',
|
||
confirmTruncateTableTitle: "Tronca Tabella",
|
||
confirmTruncateTableMessage: 'Sei sicuro di voler troncare (TRUNCATE) la tabella "{name}"? Questa operazione rimuoverà tutte le righe.',
|
||
dropTableSuccess: 'Tabella "{name}" eliminata',
|
||
editView: "Modifica Vista",
|
||
viewSource: "Visualizza Origine",
|
||
viewDdl: "Visualizza DDL",
|
||
viewDdlLoading: "Caricamento DDL...",
|
||
ddlCopied: "DDL copiato",
|
||
dropObject: "Elimina Oggetto",
|
||
dropView: "Elimina Vista",
|
||
dropColumn: "Elimina Colonna",
|
||
dropIndex: "Elimina Indice",
|
||
dropAllIndexes: "Elimina tutti gli indici",
|
||
dropForeignKey: "Elimina Chiave Esterna",
|
||
dropTrigger: "Elimina Trigger",
|
||
batchDrop: "Elimina selezionati ({count})",
|
||
batchEmpty: "Svuota selezionate ({count})",
|
||
batchTruncate: "Tronca selezionate ({count})",
|
||
batchDropIndexes: "Elimina indici ({count})",
|
||
executeProcedure: "Esegui Procedura",
|
||
confirmExecuteProcedureTitle: "Esegui Procedura",
|
||
confirmExecuteProcedureMessage: 'Eseguire la procedura "{name}"? È possibile compilare o regolare i valori dei parametri prima.',
|
||
loadingProcedureParameters: "Caricamento parametri...",
|
||
procedureParametersUnavailable: "Impossibile caricare i metadati dei parametri. Puoi comunque modificare l'SQL di seguito ed eseguirlo.",
|
||
noProcedureParameters: "Nessun parametro trovato. L'SQL corrente verrà eseguito come mostrato.",
|
||
inputParameters: "{count} parametri di input",
|
||
outputParameters: "{count} parametri di output",
|
||
parameterName: "Nome",
|
||
parameterType: "Tipo",
|
||
parameterMode: "Modalità",
|
||
parameterValue: "Valore",
|
||
parameterNull: "NULL",
|
||
parameterDefault: "DEFAULT",
|
||
parameterDefaultHint: "Quando DEFAULT è selezionato, DBX omette quell'argomento in modo che il database utilizzi il valore predefinito della procedura.",
|
||
parameterValuePlaceholder: "Inserisci valore",
|
||
outputOnly: "Solo output",
|
||
sqlPreview: "Anteprima SQL",
|
||
resetSqlPreview: "Reimposta SQL",
|
||
openInSqlEditor: "Apri nell'Editor",
|
||
dropProcedure: "Elimina Procedura",
|
||
dropFunction: "Elimina Funzione",
|
||
confirmDropViewTitle: "Elimina Vista",
|
||
confirmDropViewMessage: 'Sei sicuro di voler eliminare la vista "{name}"?',
|
||
confirmDropObjectTitle: "Elimina Oggetto",
|
||
confirmDropObjectMessage: 'Sei sicuro di voler eliminare "{name}"?',
|
||
confirmDropColumnTitle: "Elimina Colonna",
|
||
confirmDropIndexTitle: "Elimina Indice",
|
||
confirmDropMongoIndexMessage: 'Vuoi eliminare l\'indice "{name}" dalla collection "{collection}"?',
|
||
confirmDropMongoAllIndexesMessage: 'Vuoi eliminare tutti gli indici rimovibili dalla collection "{name}"?',
|
||
confirmDropMongoAllIndexesDetails: 'MongoDB mantiene l\'indice "_id_". Altri indici richiesti dalla shard key potrebbero restare; il risultato elencherà solo quelli effettivamente eliminati.',
|
||
confirmDropForeignKeyTitle: "Elimina Chiave Esterna",
|
||
confirmDropTriggerTitle: "Elimina Trigger",
|
||
confirmDropTableChildObjectMessage: 'Sei sicuro di voler eliminare "{name}" da "{table}"?',
|
||
confirmDropBatchIndexesMessage: 'Sei sicuro di voler eliminare {count} indici selezionati da "{table}"? Questa azione non può essere annullata.',
|
||
confirmBatchDropTitle: "Elimina Oggetti Selezionati",
|
||
confirmBatchDropMessage: "Sei sicuro di voler eliminare {count} oggetti selezionati? Questa azione non può essere annullata.",
|
||
confirmBatchEmptyTitle: "Svuota Tabelle Selezionate",
|
||
confirmBatchEmptyMessage: "Sei sicuro di voler eliminare tutti i dati da {count} tabelle selezionate?",
|
||
confirmBatchTruncateTitle: "Tronca Tabelle Selezionate",
|
||
confirmBatchTruncateMessage: "Sei sicuro di voler troncare {count} tabelle selezionate? Questa operazione rimuoverà tutte le righe.",
|
||
confirmDropProcedureTitle: "Elimina Procedura",
|
||
confirmDropProcedureMessage: 'Sei sicuro di voler eliminare la procedura "{name}"?',
|
||
confirmDropFunctionTitle: "Elimina Funzione",
|
||
confirmDropFunctionMessage: 'Sei sicuro di voler eliminare la funzione "{name}"?',
|
||
dropViewSuccess: 'Vista "{name}" eliminata',
|
||
dropProcedureSuccess: 'Procedura "{name}" eliminata',
|
||
dropFunctionSuccess: 'Funzione "{name}" eliminata',
|
||
dropTableChildObjectSuccess: '"{name}" eliminato',
|
||
dropAllIndexesSuccess: 'Eliminati {count} indici da "{name}"',
|
||
batchDropSuccess: "Eliminati {count} oggetti",
|
||
batchEmptySuccess: "Svuotate {count} tabelle",
|
||
batchEmptyPartialFail: "Svuotate {success} tabelle, {failed} non riuscite",
|
||
batchEmptySubmitted: "Inviate attività di svuotamento per {count} tabelle",
|
||
batchEmptySubmittedPartial: "Inviate {success} attività, {failed} non riuscite",
|
||
batchTruncateSuccess: "Troncate {count} tabelle",
|
||
emptyTableSuccess: 'Tutti i dati eliminati da "{name}"',
|
||
emptyTableSubmitted: 'Attività di svuotamento inviata per "{name}"',
|
||
truncateTableSuccess: 'Tabella "{name}" troncata',
|
||
duplicateStructureSuccess: 'Tabella clonata come "{name}"',
|
||
tableOperationFailed: "Operazione non riuscita: {message}",
|
||
duplicateNameTitle: "Clona as Nuova Tabella",
|
||
duplicateNamePlaceholder: "Nuovo nome tabella",
|
||
copyTable: "Copia tabella",
|
||
pasteTable: "Incolla tabella",
|
||
pasteOptionStructureAndData: "Struttura e dati",
|
||
pasteOptionStructureOnly: "Solo struttura",
|
||
pasteOptionDataOnly: "Solo dati",
|
||
pasteTableSuccess: 'Tabella incollata come "{name}"',
|
||
pasteTableConfirmTitle: "Incolla tabella",
|
||
pasteTableConfirmMessage: "Incolla tabella dagli appunti",
|
||
batchPasteTitle: "Incolla tabelle",
|
||
batchPasteSuccess: "{count} tabelle incollate correttamente",
|
||
batchPastePartialFail: "{success} tabelle incollate, {failed} fallite",
|
||
noTableToPaste: "Nessuna tabella disponibile da incollare",
|
||
pasteTableClipboardUpdated: "Tabella copiata negli appunti",
|
||
createDatabase: "Crea Database",
|
||
createDuckDbFile: "Crea File Database",
|
||
dropDatabase: "Elimina Database",
|
||
confirmDropDatabaseTitle: "Elimina Database",
|
||
confirmDropDatabaseMessage: 'Sei sicuro di voler eliminare il database "{name}"? Questa operazione eliminerà permanentemente il database e tutti i suoi dati.',
|
||
createDatabaseSuccess: 'Database "{name}" creato',
|
||
editDatabaseProperties: "Modifica proprietà database",
|
||
editDatabasePropertiesTitle: 'Modifica proprietà database: "{name}"',
|
||
editDatabasePropertiesSaving: "Salvataggio...",
|
||
editDatabasePropertiesSuccess: 'Proprietà del database "{name}" aggiornate',
|
||
editDatabaseComment: "Commento database",
|
||
editDatabaseCommentPlaceholder: "Inserisci commento database...",
|
||
createDuckDbFileSuccess: 'File di database DuckDB "{name}" creato e collegato',
|
||
createDuckDbFileDesktopOnly: "La creazione di file di database DuckDB è disponibile solo nell'applicazione desktop",
|
||
dropDatabaseSuccess: 'Database "{name}" eliminato',
|
||
dropCollection: "Elimina Collection",
|
||
confirmDropCollectionTitle: "Elimina Collection",
|
||
confirmDropCollectionMessage: 'Sei sicuro di voler eliminare la collection "{name}"? Questa operazione eliminerà permanentemente la collection e tutti i suoi documenti.',
|
||
dropCollectionSuccess: 'Collection "{name}" eliminata',
|
||
createDatabaseNamePlaceholder: "Nome database",
|
||
createDatabaseCharset: "Set di caratteri",
|
||
createDatabaseCharsetPlaceholder: "es. utf8mb4",
|
||
createDatabaseCharsetSearchPlaceholder: "Cerca o digita un set di caratteri",
|
||
createDatabaseCharsetEmpty: "Nessun set di caratteri trovato",
|
||
createDatabaseCharsetLoading: "Caricamento set di caratteri...",
|
||
createDatabaseCharsetCustomOption: 'Usa "{value}"',
|
||
createDatabaseCollation: "Collation",
|
||
createDatabaseCollationPlaceholder: "es. utf8mb4_unicode_ci",
|
||
createDatabaseCollationSearchPlaceholder: "Cerca o digita una collation",
|
||
createDatabaseCollationEmpty: "Nessuna collation trovata",
|
||
createDatabaseCollationLoading: "Caricamento collation...",
|
||
createDatabaseCollationCustomOption: 'Usa "{value}"',
|
||
createSchema: "Crea Schema",
|
||
dropSchema: "Elimina Schema",
|
||
confirmDropSchemaTitle: "Elimina Schema",
|
||
confirmDropSchemaMessage: 'Sei sicuro di voler eliminare lo schema "{name}"? Questa operazione eliminerà permanentemente lo schema e tutti i suoi oggetti.',
|
||
createSchemaSuccess: 'Schema "{name}" creato',
|
||
dropSchemaSuccess: 'Schema "{name}" eliminato',
|
||
createSchemaNamePlaceholder: "Nome schema",
|
||
editSchemaComment: "Modifica commento",
|
||
editSchemaCommentTitle: 'Modifica commento: "{name}"',
|
||
schemaCommentPlaceholder: "Inserisci commento schema...",
|
||
schemaCommentSaving: "Salvataggio...",
|
||
editSchemaCommentSuccess: 'Commento dello schema "{name}" aggiornato',
|
||
manageExtension: "Gestisci estensione...",
|
||
dropExtension: "Elimina estensione",
|
||
processList: "Elenco processi",
|
||
serverDashboard: "Dashboard del server",
|
||
},
|
||
visibleDatabases: {
|
||
title: "Database Visibili",
|
||
description: 'Scegli quali database mostrare sotto "{connection}".',
|
||
searchPlaceholder: "Cerca database...",
|
||
selectedCount: "{selected}/{total} selezionati",
|
||
selectAll: "Seleziona tutto",
|
||
selectFiltered: "Seleziona risultati ricerca",
|
||
clear: "Cancella",
|
||
showAll: "Mostra tutto",
|
||
showSystemDatabases: "Mostra database di sistema",
|
||
save: "Salva",
|
||
emptySelection: "Seleziona almeno un database, oppure usa Mostra tutto per rimuovere il filtro.",
|
||
loadFailed: "Impossibile caricare i database: {message}",
|
||
},
|
||
visibleSchemas: {
|
||
title: "Filtro Schema",
|
||
description: 'Scegli quali schema mostrare sotto "{connection}".',
|
||
searchPlaceholder: "Cerca schema...",
|
||
selectedCount: "{selected}/{total} selezionati",
|
||
selectAll: "Seleziona tutto",
|
||
selectFiltered: "Seleziona risultati ricerca",
|
||
clear: "Cancella",
|
||
showAll: "Mostra tutto",
|
||
save: "Salva",
|
||
emptySelection: "Seleziona almeno uno schema, oppure usa Mostra tutto per rimuovere il filtro.",
|
||
loadFailed: "Impossibile caricare gli schema: {message}",
|
||
},
|
||
tree: {
|
||
savedSql: "Libreria SQL",
|
||
userAdmin: "Utenti e Privilegi",
|
||
damengJobAdmin: "Job agente",
|
||
linkedServers: "Server Collegati",
|
||
defaultDatabase: "DB Predefinito",
|
||
columns: "Colonne",
|
||
indexes: "Indici",
|
||
foreignKeys: "Chiavi Esterne",
|
||
triggers: "Trigger",
|
||
tables: "Tabelle",
|
||
views: "Viste",
|
||
materializedViews: "Viste Materializzate",
|
||
procedures: "Procedure",
|
||
functions: "Funzioni",
|
||
sequences: "Sequenze",
|
||
packages: "Pacchetti",
|
||
partitions: "Partizioni",
|
||
childTables: "Sottotabelle",
|
||
loadMore: "Carica altro...",
|
||
objectBrowser: "Sfoglia in Esplora Oggetti ({count})",
|
||
extensions: "Estensioni",
|
||
},
|
||
userAdmin: {
|
||
title: "Utenti e Privilegi",
|
||
unsupported: "Connessioni compatibili con MySQL e PostgreSQL sono supportate. SQL Server, Oracle e altri modelli di autorizzazione possono essere aggiunti in seguito.",
|
||
newUser: "Nuovo Utente",
|
||
anonymous: "Anonimo",
|
||
roleName: "Nome ruolo",
|
||
allowLogin: "Consenti login",
|
||
searchUser: "Cerca utente o host",
|
||
loadingUsers: "Caricamento utenti...",
|
||
loadingGrants: "Caricamento privilegi...",
|
||
emptyUsers: "Nessun utente trovato, oppure l'account corrente non puo leggere l'elenco utenti.",
|
||
pluginUnknown: "Plugin di autenticazione sconosciuto",
|
||
grants: "Privilegi",
|
||
noGrants: "Nessun privilegio trovato",
|
||
privilegeEditor: "Editor Privilegi",
|
||
privilegeHint: "Scegli privilegi, database e tabella, quindi visualizza l'anteprima SQL prima di applicare. * indica globale o tutte le tabelle.",
|
||
database: "Database",
|
||
schema: "Schema",
|
||
table: "Tabella",
|
||
scope: "Ambito concessione",
|
||
scopeDatabase: "Database",
|
||
scopeSchema: "Schema",
|
||
scopeTable: "Tabella",
|
||
scopeRole: "Appartenenza ruolo",
|
||
memberRole: "Ruolo membro",
|
||
privileges: "Privilegi",
|
||
grantOption: "Consenti ulteriori concessioni (WITH GRANT OPTION)",
|
||
adminOption: "Consenti gestione appartenenza (WITH ADMIN OPTION)",
|
||
grant: "Concedi",
|
||
revoke: "Revoca",
|
||
username: "Nome utente",
|
||
host: "Host",
|
||
changePassword: "Cambia Password",
|
||
newPassword: "Nuova password",
|
||
lock: "Blocca",
|
||
unlock: "Sblocca",
|
||
disableLogin: "Disabilita Login",
|
||
enableLogin: "Abilita Login",
|
||
dropUser: "Elimina Utente",
|
||
previewSql: "Anteprima SQL",
|
||
sqlPreview: "Anteprima SQL",
|
||
applySql: "Applica SQL",
|
||
applySuccess: "Privilegi utente aggiornati",
|
||
applyFailed: "Esecuzione non riuscita: {message}",
|
||
},
|
||
damengJobAdmin: {
|
||
title: "Job agente Dameng",
|
||
unsupported: "Questa pagina supporta solo connessioni Dameng.",
|
||
initEnvironment: "Inizializza ambiente job",
|
||
environmentReady: "Ambiente job inizializzato",
|
||
newJob: "Nuovo job",
|
||
searchJob: "Cerca job",
|
||
loadFailed: "Caricamento non riuscito",
|
||
environmentMissingTitle: "Ambiente job non inizializzato",
|
||
environmentMissingHint: "Questo database non ha ancora l'ambiente SYSJOB.",
|
||
environmentMissingDescription: "I job agente Dameng dipendono da tabelle e viste di sistema nello schema SYSJOB. Inizializza prima l'ambiente job; di solito sono necessari privilegi amministrativi.",
|
||
emptyJobs: "Nessun job trovato, oppure l'account corrente non puo leggere l'elenco dei job.",
|
||
emptyDetails: "Nessuna riga di dettaglio",
|
||
selectJob: "Seleziona un job",
|
||
enabled: "Abilitato",
|
||
disabled: "Disabilitato",
|
||
running: "In esecuzione",
|
||
enable: "Abilita",
|
||
disable: "Disabilita",
|
||
runAsync: "Esegui ora",
|
||
stopRunning: "Ferma esecuzione corrente",
|
||
stopRunningDisabled: "Solo i job attualmente in esecuzione possono essere fermati",
|
||
clearHistories: "Cancella cronologia",
|
||
dropJob: "Elimina",
|
||
steps: "Passi",
|
||
schedules: "Pianificazioni",
|
||
histories: "Cronologia",
|
||
noDescription: "Nessuna descrizione",
|
||
jobName: "Nome job",
|
||
description: "Descrizione",
|
||
stepName: "Nome passo",
|
||
scheduleName: "Nome pianificazione",
|
||
sqlCommand: "Script SQL",
|
||
scheduleMode: "Tipo pianificazione",
|
||
daily: "Giornaliero",
|
||
once: "Una volta",
|
||
startDate: "Data inizio",
|
||
startTime: "Ora inizio",
|
||
endTime: "Ora fine",
|
||
minuteInterval: "Intervallo in minuti",
|
||
previewSql: "Anteprima SQL",
|
||
sqlPreview: "Anteprima SQL",
|
||
applySql: "Applica SQL",
|
||
applySuccess: "Operazione job applicata",
|
||
applyFailed: "Esecuzione non riuscita: {message}",
|
||
},
|
||
objects: {
|
||
all: "Tutti",
|
||
tables: "Tabelle",
|
||
views: "Viste",
|
||
procedures: "Procedure",
|
||
functions: "Funzioni",
|
||
sequences: "Sequenze",
|
||
packages: "Pacchetti",
|
||
table: "Tabella",
|
||
partitions: "{count} partizioni",
|
||
view: "Vista",
|
||
procedure: "Procedura",
|
||
function: "Funzione",
|
||
sequence: "Sequenza",
|
||
package: "Pacchetto",
|
||
packageBody: "Corpo del Pacchetto",
|
||
name: "Nome",
|
||
type: "Tipo",
|
||
rows: "Righe",
|
||
size: "Dimensione",
|
||
statisticsHint: "Stimato dalle statistiche del database; COUNT(*) non viene eseguito.",
|
||
createdAt: "Creato",
|
||
updatedAt: "Aggiornato",
|
||
source: "Codice Sorgente",
|
||
saveSource: "Salva",
|
||
cancelEdit: "Annulla",
|
||
sourceSaved: "Sorgente salvato",
|
||
sourceSaveFailed: "Impossibile salvare il sorgente: {message}",
|
||
schemaColumn: "Schema",
|
||
comment: "Commento",
|
||
loadingSchemas: "Caricamento schemi...",
|
||
schema: "Schema",
|
||
search: "Cerca tabelle, viste, funzioni, sequenze o procedure...",
|
||
loading: "Caricamento oggetti...",
|
||
empty: "Nessun oggetto trovato",
|
||
selectedTables: "{count} tabelle selezionate",
|
||
exportSelected: "Esporta selezionate",
|
||
dropSelected: "Elimina selezionate",
|
||
truncateSelected: "Tronca selezionate",
|
||
clearSelection: "Cancella selezione",
|
||
confirmBatchDropTitle: "Elimina Tabelle Selezionate",
|
||
confirmBatchDropMessage: "Sei sicuro di voler eliminare {count} tabelle selezionate? Questa azione non può essere annullata.",
|
||
confirmBatchTruncateTitle: "Tronca Tabelle Selezionate",
|
||
confirmBatchTruncateMessage: "Sei sicuro di voler troncare {count} tabelle selezionate? Questa operazione rimuoverà tutte le righe.",
|
||
batchDropSuccess: "Eliminate {count} tabelle",
|
||
batchTruncateSuccess: "Troncate {count} tabelle",
|
||
copyTableSelected: "Copia",
|
||
pasteTableSelected: "Incolla",
|
||
toggleCheckbox: "Attiva/disattiva selezione multipla",
|
||
viewList: "Vista elenco",
|
||
viewGrid: "Vista griglia",
|
||
sourceReadOnly: "Il codice sorgente è di sola lettura, non modificabile.",
|
||
sortAsc: "Crescente",
|
||
sortDesc: "Decrescente",
|
||
sortBy: "Ordina per",
|
||
},
|
||
structureEditor: {
|
||
mysqlDataTypeHelp: {
|
||
tinyint: "Intero da 1 byte: con segno da -128 a 127, senza segno da 0 a 255.",
|
||
smallint: "Intero da 2 byte: con segno da -32.768 a 32.767, senza segno da 0 a 65.535.",
|
||
mediumint: "Intero da 3 byte: con segno da -8.388.608 a 8.388.607, senza segno da 0 a 16.777.215.",
|
||
int: "Intero da 4 byte: con segno da -2.147.483.648 a 2.147.483.647, senza segno da 0 a 4.294.967.295.",
|
||
bigint: "Intero da 8 byte: con segno da -2^63 a 2^63-1, senza segno da 0 a 2^64-1.",
|
||
decimal: "Numero decimale esatto; MySQL supporta fino a 65 cifre e scala 30. Usarlo per denaro.",
|
||
float: "Numero approssimato a precisione singola; per decimali esatti usare DECIMAL.",
|
||
double: "Numero approssimato a doppia precisione; per decimali esatti usare DECIMAL.",
|
||
real: "Alias di DOUBLE per impostazione predefinita; REAL_AS_FLOAT lo rende alias di FLOAT.",
|
||
bit: "Campo da 1 a 64 bit; larghezza predefinita 1.",
|
||
boolean: "Alias di TINYINT(1): 0 è falso e un valore non zero è vero.",
|
||
serial: "Alias pratico di BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE.",
|
||
date: "Data di calendario da 1000-01-01 a 9999-12-31.",
|
||
datetime: "Data e ora senza conversione di fuso; precisione frazionaria da 0 a 6, predefinita 0.",
|
||
timestamp: "Data e ora convertita tra fuso sessione e UTC; precisione frazionaria da 0 a 6.",
|
||
time: "Ora o intervallo da -838:59:59 a 838:59:59; precisione frazionaria da 0 a 6.",
|
||
year: "Anno a quattro cifre da 1901 a 2155, oltre a 0000.",
|
||
char: "Stringa a lunghezza fissa fino a 255 caratteri, riempita con spazi.",
|
||
varchar: "Stringa a lunghezza variabile; il massimo dipende da riga e set di caratteri.",
|
||
tinytext: "Testo variabile fino a 255 byte; riga, charset e max_allowed_packet possono ridurlo.",
|
||
text: "Testo variabile fino a 65.535 byte; riga, charset e max_allowed_packet possono ridurlo.",
|
||
mediumtext: "Testo variabile fino a 16.777.215 byte; riga, charset e max_allowed_packet possono ridurlo.",
|
||
longtext: "Testo variabile fino a 4.294.967.295 byte; riga, charset e max_allowed_packet possono ridurlo.",
|
||
binary: "Stringa binaria fissa fino a 255 byte, riempita con 0x00.",
|
||
varbinary: "Stringa binaria variabile; il massimo dipende dalla dimensione della riga.",
|
||
tinyblob: "Oggetto binario fino a 255 byte; max_allowed_packet può limitarlo.",
|
||
blob: "Oggetto binario fino a 65.535 byte; max_allowed_packet può limitarlo.",
|
||
mediumblob: "Oggetto binario fino a 16.777.215 byte; max_allowed_packet può limitarlo.",
|
||
longblob: "Oggetto binario fino a 4.294.967.295 byte; max_allowed_packet può limitarlo.",
|
||
enum: "Un valore tra fino a 65.535 letterali; cambiare l'ordine può alterare il significato memorizzato.",
|
||
set: "Zero o più valori tra fino a 64 membri dichiarati.",
|
||
json: "Documento JSON validato; rappresentazione e funzioni dipendono da prodotto/versione; limitato da max_allowed_packet.",
|
||
jsonMysql: "JSON binario nativo MySQL con validazione e funzioni JSON; limitato da max_allowed_packet.",
|
||
jsonMariaDb: "In MariaDB JSON è alias di LONGTEXT con JSON_VALID e collazione utf8mb4_bin.",
|
||
nationalCharacter: "Alias di stringa nazionale; MySQL usa utf8mb3, deprecato; preferire utf8mb4.",
|
||
geometry: "Geometria spaziale; un indice SPATIAL InnoDB richiede NOT NULL e attributo SRID.",
|
||
point: "Punto spaziale; SPATIAL InnoDB richiede NOT NULL e SRID.",
|
||
linestring: "Curva spaziale; SPATIAL InnoDB richiede NOT NULL e SRID.",
|
||
polygon: "Superficie spaziale; SPATIAL InnoDB richiede NOT NULL e SRID.",
|
||
multipoint: "Raccolta di punti; SPATIAL InnoDB richiede NOT NULL e SRID.",
|
||
multilinestring: "Raccolta di curve; SPATIAL InnoDB richiede NOT NULL e SRID.",
|
||
multipolygon: "Raccolta di poligoni; SPATIAL InnoDB richiede NOT NULL e SRID.",
|
||
geometrycollection: "Raccolta di geometrie miste; SPATIAL InnoDB richiede NOT NULL e SRID.",
|
||
inet4: "Tipo IPv4 MariaDB disponibile da 10.10; memorizza l'indirizzo in quattro byte.",
|
||
inet6: "Tipo compatibile MariaDB per IPv6 e IPv4 mappato.",
|
||
uuid: "Identificatore universale univoco a 128 bit fornito da server compatibili.",
|
||
vector: "Tipo vettore per similarità o ML; disponibilità e dimensioni dipendono dalla versione.",
|
||
xmltype: "Tipo XML fornito da server compatibili.",
|
||
integerDisplayWidth: "La larghezza di visualizzazione intera, ad esempio INT(11), è deprecata e non limita l'intervallo.",
|
||
zerofill: "ZEROFILL è deprecato in MySQL 8 e implica UNSIGNED; formattare nell'applicazione.",
|
||
unsignedNumeric: "UNSIGNED per DECIMAL, FLOAT o DOUBLE è deprecato in MySQL 8; usare CHECK per valori non negativi.",
|
||
floatPrecision: "In FLOAT(p), p da 25 a 53 seleziona DOUBLE; usare DOUBLE esplicitamente.",
|
||
floatingPointDisplay: "FLOAT(M,D) e DOUBLE(M,D) sono deprecati; usare FLOAT/DOUBLE senza parametri o DECIMAL(M,D).",
|
||
},
|
||
postgresDataTypeHelp: {
|
||
smallint: "Intero con segno da 2 byte, da -32.768 a 32.767.",
|
||
integer: "Intero con segno da 4 byte, da -2.147.483.648 a 2.147.483.647.",
|
||
bigint: "Intero con segno da 8 byte, da -2^63 a 2^63-1.",
|
||
serial: "Sintassi pratica che crea intero, sequenza, NOT NULL e default nextval; non è unico da solo e può avere lacune; preferire IDENTITY.",
|
||
numeric: "Decimale esatto con precisione e scala; usarlo per denaro e valori senza arrotondamento binario.",
|
||
real: "Floating point a precisione singola da 4 byte; FLOAT(p) da 1 a 24 lo seleziona.",
|
||
double: "Floating point a doppia precisione da 8 byte; FLOAT senza precisione è alias e FLOAT(p) da 25 a 53 lo seleziona.",
|
||
money: "Importo monetario dipendente da lc_monetary; NUMERIC è più sicuro per dati finanziari portabili.",
|
||
boolean: "Valore logico vero, falso o nullo; BOOL è alias di BOOLEAN.",
|
||
char: "Stringa fissa riempita di spazi; CHARACTER è alias.",
|
||
varchar: "Stringa variabile con limite opzionale; CHARACTER VARYING è alias.",
|
||
text: "Stringa variabile senza limite dichiarato; stessa memorizzazione di VARCHAR senza limite.",
|
||
bytea: "Stringa binaria variabile; TOAST può memorizzare valori grandi fuori riga.",
|
||
date: "Data di calendario senza ora né fuso.",
|
||
time: "Ora senza fuso, con precisione frazionaria opzionale.",
|
||
timetz: "Ora con offset UTC; uso limitato, preferire timestamptz per un istante.",
|
||
timestamp: "Data e ora senza conversione di fuso per valori locali.",
|
||
timestamptz: "Istante memorizzato in UTC e mostrato nel fuso della sessione; non conserva il fuso originale.",
|
||
interval: "Durata in mesi, giorni e microsecondi; le unità di calendario non hanno durata fissa.",
|
||
uuid: "Identificatore universale univoco a 128 bit.",
|
||
json: "Testo JSON nella rappresentazione originale; validato al parsing ma generalmente più lento di JSONB.",
|
||
jsonb: "JSON binario decomposto ottimizzato per elaborazione e indici; non conserva spazi, ordine o chiavi duplicate.",
|
||
xml: "Valore XML con validazione di documento o contenuto secondo l'opzione.",
|
||
bit: "Stringa di bit fissa o variabile; BIT VARYING e VARBIT sono alias variabili.",
|
||
tsvector: "Lessemi normalizzati per ricerca full-text; spesso indicizzati con GIN o GiST.",
|
||
tsquery: "Query full-text booleana valutata contro un tsvector.",
|
||
cidr: "Rete IPv4 o IPv6 con bit host vincolati a zero.",
|
||
inet: "Host IPv4 o IPv6 con maschera opzionale; diversamente da CIDR può avere bit host non zero.",
|
||
macaddr: "Indirizzo MAC; MACADDR usa 6 byte e MACADDR8 usa 8 byte.",
|
||
geometry: "Tipo geometrico piano bidimensionale senza SRID; usare PostGIS per coordinate geografiche e operazioni avanzate.",
|
||
range: "Intervallo continuo con limiti inclusivi/esclusivi; usare multirange per intervalli separati.",
|
||
oid: "Identificatore oggetto senza segno di sistema; non è una chiave primaria applicativa durevole.",
|
||
array: "Array PostgreSQL di qualunque elemento, anche multidimensionale; le dimensioni dichiarate non sono imposte.",
|
||
multirange: "Insieme di intervalli non sovrapposti; PostgreSQL normalizza membri adiacenti o sovrapposti.",
|
||
jsonpath: "Espressione percorso SQL/JSON usata da query e predicati JSONB.",
|
||
pgLsn: "Posizione WAL per replica e recupero; non è un numero di sequenza applicativo.",
|
||
pgSnapshot: "Snapshot di visibilità delle transazioni per operazioni database, non dati applicativi generali.",
|
||
},
|
||
sqliteDataTypeHelp: {
|
||
integer: "Affinità INTEGER; una colonna normale non impone questa classe. INTEGER PRIMARY KEY esatto è alias di rowid.",
|
||
real: "Affinità REAL con IEEE 754; non adatta a denaro esatto.",
|
||
text: "Affinità TEXT; VARCHAR(n) e CHAR(n) non impongono n; usare CHECK se la lunghezza conta.",
|
||
blob: "Affinità BLOB: memorizza byte senza conversione.",
|
||
numeric: "Affinità NUMERIC converte testo numerico prima in INTEGER e poi in REAL; anche DATE, DATETIME e TIME la usano.",
|
||
},
|
||
title: "Modifica Struttura Tabella",
|
||
createTitle: "Crea Tabella",
|
||
editTabTitle: "Modifica: {tableName}",
|
||
tableName: "Nome Tabella",
|
||
refresh: "Aggiorna Struttura",
|
||
density: "Densità",
|
||
densityCompact: "Compatta",
|
||
densityStandard: "Standard",
|
||
densityComfortable: "Comoda",
|
||
columns: "Colonne",
|
||
indexes: "Indici",
|
||
foreignKeys: "Chiavi Esterne",
|
||
triggers: "Trigger",
|
||
ddl: "DDL",
|
||
addColumn: "Aggiungi Colonna",
|
||
columnTemplates: "Inserisci campi predefiniti",
|
||
configureColumnTemplates: "Configura campi predefiniti",
|
||
presetFieldsTemplate: "Set di campi predefiniti",
|
||
searchColumns: "Cerca colonna/commento",
|
||
nextColumnMatch: "Vai alla prossima colonna corrispondente",
|
||
searchIndexes: "Cerca indice",
|
||
nextIndexMatch: "Vai al prossimo indice corrispondente",
|
||
addIndex: "Aggiungi Indice",
|
||
addForeignKey: "Aggiungi Chiave Esterna",
|
||
addTrigger: "Aggiungi Trigger",
|
||
columnName: "Colonna",
|
||
dataType: "Tipo",
|
||
typePlaceholder: "Seleziona o digita...",
|
||
noMatchingType: "Nessun tipo corrispondente",
|
||
length: "Lunghezza",
|
||
lengthUnit: "Unità di lunghezza",
|
||
unitPlaceholder: "Unità",
|
||
nullable: "Nullabile",
|
||
primaryKey: "Chiave Primaria",
|
||
defaultValue: "Valore Predefinito",
|
||
defaultValuePresets: "Preimpostazioni valore predefinito",
|
||
comment: "Commento",
|
||
characterSet: "Set di caratteri",
|
||
charsetPlaceholder: "Charset",
|
||
collation: "Regole di confronto",
|
||
collationPlaceholder: "Regole di confronto",
|
||
editComment: "Modifica commento",
|
||
commentPlaceholder: "Inserisci commento colonna...",
|
||
tableCommentPlaceholder: "Inserisci commento tabella...",
|
||
tableCommentUnsupported: "I commenti della tabella non sono supportati da questo database",
|
||
actions: "Azioni",
|
||
indexName: "Indice",
|
||
indexColumns: "Colonne",
|
||
indexColumnsPlaceholder: "Seleziona colonne...",
|
||
unique: "Unico",
|
||
indexType: "Tipo",
|
||
includedColumns: "Incluse",
|
||
includedColumnsPlaceholder: "Seleziona colonne...",
|
||
filter: "Filtro",
|
||
foreignKeyName: "Chiave esterna",
|
||
referencedSchema: "Schema rif.",
|
||
referencedTable: "Tabella rif.",
|
||
referencedColumn: "Colonna rif.",
|
||
onDelete: "On delete",
|
||
onUpdate: "On update",
|
||
defaultAction: "Predefinito",
|
||
triggerName: "Trigger",
|
||
triggerStatement: "Istruzione trigger",
|
||
primary: "Primario",
|
||
drop: "Elimina",
|
||
restore: "Ripristina",
|
||
remove: "Rimuovi",
|
||
moveColumnUp: "Sposta colonna su",
|
||
moveColumnDown: "Sposta colonna giù",
|
||
dragColumn: "Trascina per riordinare la colonna",
|
||
localColumnOrderNotice: "L'ordine delle colonne viene salvato solo localmente e non modifica la struttura del database.",
|
||
yes: "Sì",
|
||
no: "No",
|
||
emptyReadonly: "Nessun record",
|
||
sqlPreview: "Anteprima SQL",
|
||
collapseSqlPreview: "Comprimi anteprima SQL",
|
||
expandSqlPreview: "Espandi anteprima SQL",
|
||
noChanges: "Nessuna modifica",
|
||
apply: "Applica Modifiche",
|
||
ready: "Pronto",
|
||
saved: "Struttura tabella aggiornata",
|
||
copySql: "Copia SQL",
|
||
sqliteRebuildNotice: "SQLite conserva uno snapshot di dati inerte come backup, ricostruisce la tabella in un'unica transazione e forza CAST sulle colonne modificate. I valori non rappresentabili possono diventare 0/0.0; in caso di errore, tutte le modifiche vengono annullate.",
|
||
extendedProperties: "Esteso",
|
||
autoIncrement: "Auto Incremento",
|
||
onUpdateCurrentTimestamp: "Aggiorna Ora Automaticamente",
|
||
identity: "Identità",
|
||
identityGeneration: "Generazione",
|
||
identitySeed: "Seed",
|
||
identityIncrement: "Incremento",
|
||
sqlServerIdentityTypeHint: "Identity di SQL Server supporta solo tinyint, smallint, int, bigint e decimal/numeric con scala 0",
|
||
},
|
||
diagram: {
|
||
title: "Diagramma delle Relazioni",
|
||
open: "Visualizza Diagramma",
|
||
selectConnection: "Seleziona connessione",
|
||
selectDatabase: "Seleziona database",
|
||
selectSchema: "Seleziona schema",
|
||
searchTables: "Cerca tabelle, colonne, chiavi...",
|
||
refresh: "Aggiorna diagramma",
|
||
loading: "Lettura relazioni...",
|
||
loadingProgress: "Lettura relazioni... {loaded}/{total}",
|
||
partialError: "Saltati i metadati per {count} tabelle che non è stato possibile caricare",
|
||
selectTarget: "Seleziona una connessione e un database",
|
||
empty: "Nessuna tabella da visualizzare",
|
||
noMatches: "Nessuna tabella corrispondente",
|
||
tablesCount: "{count} tabelle",
|
||
relationshipsCount: "{count} relazioni",
|
||
tableMode: "Visualizzazione Tabella",
|
||
engineeringMode: "ER Ingegneristico",
|
||
modelRelationships: "Relazioni Modello",
|
||
copyJoinSql: "Copia SQL",
|
||
customRelationshipsCount: "{count} modellati",
|
||
relationshipName: "Nome",
|
||
relationshipNamePlaceholder: "Opzionale",
|
||
sourceTable: "Tabella sorgente",
|
||
sourceColumn: "Colonna sorgente",
|
||
targetTable: "Tabella destinazione",
|
||
targetColumn: "Colonna destinazione",
|
||
cardinality: "Cardinalita",
|
||
cardinalityOneToMany: "1:N",
|
||
cardinalityManyToOne: "N:1",
|
||
cardinalityOneToOne: "1:1",
|
||
addRelationship: "Aggiungi relazione",
|
||
removeRelationship: "Rimuovi relazione",
|
||
relationshipIncomplete: "Seleziona sia la colonna sorgente che quella di destinazione",
|
||
relationshipSelfInvalid: "Una relazione non puo avere come destinazione la stessa colonna",
|
||
relationshipExists: "Questa relazione esiste gia",
|
||
relationshipAdded: "Relazione aggiunta",
|
||
noJoinSql: "Nessun SQL di relazione da copiare",
|
||
allTables: "Tutte le Tabelle",
|
||
relatedTables: "Tabelle Correlate",
|
||
moreColumns: "+ {count} colonne",
|
||
exportSvg: "Esporta SVG",
|
||
exportedSvg: "SVG esportato",
|
||
exportSvgFailed: "Impossibile esportare SVG: {message}",
|
||
zoomIn: "Ingrandisci",
|
||
zoomOut: "Rimpicciolisci",
|
||
resetLayout: "Reimposta layout",
|
||
},
|
||
etcd: {
|
||
prefixPlaceholder: "Prefisso, es. /app/",
|
||
newKey: "Nuova Chiave",
|
||
loadingKeys: "Caricamento chiavi...",
|
||
empty: "Nessuna chiave trovata",
|
||
loadMore: "Carica altro",
|
||
selectKey: "Seleziona una chiave per visualizzarne il valore",
|
||
loadingValue: "Caricamento valore...",
|
||
notFound: "Chiave non trovata",
|
||
edit: "Modifica",
|
||
editKey: "Modifica Chiave",
|
||
delete: "Elimina",
|
||
deleteTitle: "Elimina chiave etcd",
|
||
keyPlaceholder: "/percorso/per/la/chiave",
|
||
keyRequired: "La chiave e obbligatoria",
|
||
saved: "Chiave salvata",
|
||
deleted: "Chiave eliminata",
|
||
base64Readonly: "I valori Base64 sono in sola lettura in questa versione.",
|
||
},
|
||
zookeeper: {
|
||
prefixPlaceholder: "Prefisso percorso, es. /app/",
|
||
newKey: "Nuovo Znode",
|
||
loadingKeys: "Caricamento znodes...",
|
||
empty: "Nessuno znode trovato",
|
||
loadMore: "Carica altro",
|
||
selectKey: "Seleziona uno znode per visualizzarne il valore",
|
||
loadingValue: "Caricamento valore...",
|
||
notFound: "Znode non trovato",
|
||
edit: "Modifica",
|
||
editKey: "Modifica Znode",
|
||
delete: "Elimina",
|
||
deleteTitle: "Elimina znode ZooKeeper",
|
||
keyPlaceholder: "/percorso/per/znode",
|
||
keyRequired: "Il percorso znode e obbligatorio",
|
||
rootReadonly: "Lo znode radice non può essere modificato. Inserisci il percorso di uno znode figlio.",
|
||
saved: "Znode salvato",
|
||
deleted: "Znode eliminato",
|
||
base64Readonly: "I valori Base64 sono in sola lettura in questa versione.",
|
||
createMode: "Modalita Creazione",
|
||
createModePersistent: "Persistente",
|
||
createModeEphemeral: "Effimero",
|
||
createModePersistentSequential: "Persistente Sequenziale",
|
||
createModeEphemeralSequential: "Effimero Sequenziale",
|
||
add: "Aggiungi",
|
||
value: "Valore",
|
||
metadata: "Informazioni Nodo",
|
||
prettyJson: "Formatta",
|
||
invalidJson: "JSON non valido",
|
||
summaryRevision: "rev",
|
||
summaryVersion: "ver",
|
||
summaryLease: "lease",
|
||
summarySize: "dimensione",
|
||
},
|
||
redis: {
|
||
createKeyTypeHelp: {
|
||
string: "Valore singolo fino a 512 MB; utile per cache e contatori.",
|
||
hash: "Mappa campo-valore piatta; leggere un Hash grande intero è O(N).",
|
||
list: "Sequenza ordinata; accesso intermedio lineare.",
|
||
set: "Membri unici non ordinati; enumerare insiemi grandi è lineare.",
|
||
zset: "Membri unici con punteggio floating point; scrittura O(log N).",
|
||
stream: "Log append-only; gestire XACK, pendenti e trimming.",
|
||
json: "JSON per percorso; richiede RedisJSON/Redis Stack e costa di solito più di String o Hash.",
|
||
},
|
||
selectKey: "Seleziona una chiave per visualizzarne il valore",
|
||
noKeys: "Nessuna chiave trovata",
|
||
noKeysInScanHint: "Nessuna chiave trovata nell'intervallo di scansione corrente",
|
||
pattern: "pattern (es. user:*)",
|
||
fuzzyPattern: "la chiave contiene...",
|
||
fuzzyMatch: "Fuzzy",
|
||
fuzzyMatchTitle: "Corrispondenza fuzzy: cerca le chiavi per testo semplice contenuto",
|
||
valueSearchPlaceholder: "il valore contiene...",
|
||
allSearchPlaceholder: "la chiave o il valore contiene...",
|
||
searchByKey: "Chiave",
|
||
searchByValue: "Valore",
|
||
searchByAll: "Tutto",
|
||
searchFields: "Cerca campi e valori",
|
||
keys: "{count} chiavi",
|
||
loadedKeys: "{loaded} / {total} chiavi caricate",
|
||
loadingKeys: "Caricamento chiavi...",
|
||
searchingValues: "Ricerca nei valori...",
|
||
searchingAll: "Ricerca in chiavi e valori...",
|
||
loadMoreKeys: "Carica altre chiavi",
|
||
fetchAllKeys: "Recupera tutto",
|
||
stopFetchAll: "Interrompi",
|
||
fetchAllProgress: "{loaded} di {total} chiavi caricate",
|
||
fetchAllProgressUnknown: "{loaded} chiavi caricate",
|
||
items: "{count} elementi",
|
||
fields: "{count} campi",
|
||
members: "{count} membri",
|
||
loadedItems: "{loaded} di {total} elementi caricati",
|
||
loadedFields: "{loaded} di {total} campi caricati",
|
||
loadedMembers: "{loaded} di {total} membri caricati",
|
||
entries: "{count} voci",
|
||
noExpiry: "nessuna scadenza",
|
||
autoRefresh: "Aggiornamento automatico",
|
||
ttlDay: "{count}g",
|
||
columnType: "Tipo",
|
||
columnKey: "Chiave",
|
||
columnValue: "Valore",
|
||
columnSize: "Dimensione",
|
||
columnTTL: "TTL",
|
||
binaryStringReadonlyHint: "I valori delle stringhe binarie sono mostrati come testo con escape in modalità sola lettura; la modifica dei byte grezzi non è supportata.",
|
||
selectedKeys: "Chiavi selezionate",
|
||
deleteGroup: "Elimina gruppo",
|
||
deleteGroupDetails: "{target}\n{count} chiavi",
|
||
flushDb: "Pulisci DB corrente",
|
||
flushDbMessage: "Questo eliminerà ogni chiave nel database Redis corrente e non può essere annullato. Continuare?",
|
||
flushDbDetails: "Destinazione: Redis db{db}\nAmbito: tutte le chiavi nel DB corrente",
|
||
flushDbConfirm: "Pulisci DB",
|
||
flushDbSuccess: "Redis db{db} pulito",
|
||
keyDetail: "Dettaglio chiave",
|
||
commandLine: "Console dei comandi",
|
||
selectKeyForDetail: "Seleziona una chiave per visualizzare i dettagli",
|
||
commandWelcome: "Benvenuto nella console comandi di Redis",
|
||
commandPlaceholder: "Comando Redis, es. GET user:1",
|
||
commandPrefix: "CMD",
|
||
commandHint: "Inserisci un comando Redis, es. SMEMBERS feature:flags",
|
||
executeCommand: "Esegui comando",
|
||
commandEmpty: "Inserisci un comando Redis",
|
||
commandEmptyResult: "Esegui un comando Redis per vedere il risultato",
|
||
commandBlocked: "Questo comando Redis è bloccato per sicurezza",
|
||
createKey: "Crea chiave",
|
||
createKeyName: "Chiave",
|
||
createKeyNamePlaceholder: "user:1",
|
||
createKeyType: "Tipo",
|
||
createValue: "Valore",
|
||
createMember: "Membro",
|
||
createField: "Campo",
|
||
createFieldPlaceholder: "nome",
|
||
createScore: "Punteggio",
|
||
createKeyTtl: "TTL (secondi)",
|
||
createKeyTtlPlaceholder: "vuoto = senza scadenza",
|
||
createKeyAddEntry: "Aggiungi voce",
|
||
createKeyEntryId: "ID voce",
|
||
createKeyRawMode: "Input raw",
|
||
createKeyEntries: "Voci",
|
||
createValuePlaceholder: "valore",
|
||
createKeySubmit: "Crea",
|
||
createKeyNameRequired: "Inserisci un nome chiave",
|
||
createFieldRequired: "Inserisci un campo hash",
|
||
createScoreInvalid: "Inserisci un punteggio valido",
|
||
jsonModuleNotAvailable: "Il modulo ReJSON non è caricato su questo server Redis",
|
||
fieldRequired: "Inserisci un nome campo",
|
||
valueRequired: "Inserisci un valore",
|
||
memberRequired: "Inserisci un membro",
|
||
ttlInvalid: "Inserisci un TTL valido in secondi (-1 per nessuna scadenza)",
|
||
member: "Membro",
|
||
memberDetail: "Dettaglio membro",
|
||
viewMember: "Visualizza valore completo",
|
||
copyMember: "Copia membro",
|
||
copyKeyName: "Copia nome chiave",
|
||
copied: "Copiato",
|
||
copyInsertStatement: "Copia Istruzione di Inserimento",
|
||
copyInsertStatementBinary: "Impossibile generare l'istruzione di inserimento per dati binari",
|
||
editMember: "Modifica",
|
||
jsonView: "Visualizzazione JSON",
|
||
rawContent: "Contenuto grezzo",
|
||
wordWrap: "A capo automatico",
|
||
formatJson: "Formatta",
|
||
compressJson: "Comprimi",
|
||
jsonFormatError: "Formato JSON non valido",
|
||
clearHistory: "Cancella cronologia comandi",
|
||
historyCleared: "Cronologia comandi Redis cancellata",
|
||
blockedCommand: "Il comando {command} è bloccato per sicurezza. Disattiva l'icona scudo nella barra degli strumenti per consentirlo.",
|
||
pubsub: "Pub/Sub",
|
||
pubsubConnected: "Connesso",
|
||
pubsubConnecting: "Connessione in corso...",
|
||
pubsubDisconnected: "Disconnesso",
|
||
pubsubConnect: "Connetti",
|
||
pubsubDisconnect: "Disconnetti",
|
||
pubsubChannels: "Canali",
|
||
pubsubChannelPlaceholder: "Nome canale",
|
||
pubsubSubscribe: "Sottoscrivi",
|
||
pubsubPatterns: "Pattern",
|
||
pubsubPatternPlaceholder: "Pattern (es. news:*)",
|
||
pubsubPsubscribe: "PSottoscrivi",
|
||
pubsubMessages: "Messaggi",
|
||
pubsubClear: "Cancella",
|
||
pubsubEmpty: "Nessun messaggio. Sottoscrivi un canale per ricevere messaggi.",
|
||
pubsubPublish: "Pubblica",
|
||
pubsubPublishChannel: "Canale",
|
||
pubsubPublishMessage: "Messaggio",
|
||
pubsubSend: "Invia",
|
||
pubsubPublishFailed: "Pubblicazione fallita: {error}",
|
||
pubsubWsConnectFailed: "Connessione WebSocket fallita: {error}",
|
||
slowlog: "Slow Log",
|
||
slowlogCount: "Conteggio",
|
||
slowlogQuery: "Query",
|
||
slowlogNode: "Nodo",
|
||
slowlogSelectNode: "Seleziona un nodo",
|
||
slowlogNodeRequired: "Seleziona prima un nodo",
|
||
slowlogEmpty: "Fai clic su Query per recuperare le voci dello slow log",
|
||
slowlogFetchFailed: "Recupero slow log non riuscito: {error}",
|
||
slowlogColumnId: "ID",
|
||
slowlogColumnTimestamp: "Timestamp",
|
||
slowlogColumnDuration: "Durata (µs)",
|
||
slowlogColumnCommand: "Comando",
|
||
slowlogColumnClientAddr: "Client",
|
||
slowlogColumnClientName: "Nome Client",
|
||
slowlogTotal: "{count} voci",
|
||
slowlogDetailTitle: "Voce Slow Log #{id}",
|
||
},
|
||
mongo: {
|
||
documents: "{count} documenti",
|
||
addField: "Aggiungi Campo",
|
||
deleteField: "Elimina Campo",
|
||
field: "Campo",
|
||
value: "Valore",
|
||
fieldPlaceholder: "Nome campo",
|
||
emptyCollection: "Collezione vuota",
|
||
selectDocument: "Seleziona un documento",
|
||
readonlyId: "_id è in sola lettura",
|
||
invalidJsonValue: "Questa cella non contiene un valore JSON valido",
|
||
duplicateField: "Nome campo duplicato: {field}",
|
||
edit: "Modifica",
|
||
documentView: "Visualizzazione Documento",
|
||
tableView: "Visualizzazione Tabella",
|
||
filterPlaceholder: "Filtra...",
|
||
sortPlaceholder: "Ordina...",
|
||
},
|
||
vector: {
|
||
collectionFallback: "collezione",
|
||
productCollection: "Collezione {product}",
|
||
browse: "Sfoglia",
|
||
search: "Cerca",
|
||
upsert: "Upsert",
|
||
delete: "Elimina",
|
||
reset: "Reimposta",
|
||
refresh: "Aggiorna",
|
||
run: "Esegui",
|
||
apply: "Applica",
|
||
requestEditor: "Editor richieste vettoriali",
|
||
operationSuccess: "Operazione completata. L'anteprima della collezione e stata aggiornata.",
|
||
vectorLabel: "Vettore",
|
||
},
|
||
history: {
|
||
title: "Cronologia",
|
||
search: "Cerca nella cronologia...",
|
||
empty: "Ancora nessuna cronologia",
|
||
emptyFilteredRecent: "Nessun record corrispondente nelle ultime 200 voci della cronologia di esecuzione",
|
||
failed: "Non riuscita",
|
||
success: "Riuscita",
|
||
restore: "Ripristina nell'editor",
|
||
copy: "Copia SQL",
|
||
delete: "Elimina",
|
||
clear: "Cancella Cronologia",
|
||
viewDetails: "Visualizza dettagli",
|
||
analyzeWithAi: "Analizza con AI",
|
||
aiAnalyzeNoConnection: "Impossibile analizzare questa voce della cronologia poiché la sua connessione non esiste più.",
|
||
aiAnalysisTab: "Analisi Cronologia",
|
||
rollback: "Rollback",
|
||
rollbackSql: "SQL di Rollback",
|
||
rollbackAvailable: "Disponibile",
|
||
rollbackUnavailable: "Nessun SQL di rollback",
|
||
rollbackConfirm: "Eseguire l'SQL di rollback generato per questa voce della cronologia?",
|
||
rollbackSuccess: "Rollback eseguito",
|
||
rollbackFailed: "Rollback non riuscito: {message}",
|
||
confirmDelete: "Eliminare questa voce della cronologia?",
|
||
confirmClear: "Cancellare tutta la cronologia?",
|
||
filters: {
|
||
all: "Tutti",
|
||
query: "Query",
|
||
data_change: "Modifiche dati",
|
||
schema_change: "Modifiche schema",
|
||
failed: "Non riuscite",
|
||
},
|
||
dateRange: {
|
||
title: "Intervallo di tempo",
|
||
label: "Ora di esecuzione:",
|
||
start: "Data iniziale",
|
||
end: "Data finale",
|
||
apply: "Applica",
|
||
clear: "Cancella",
|
||
invalid: "La data iniziale non può essere successiva alla data finale",
|
||
unboundedStart: "Inizio",
|
||
unboundedEnd: "Fine",
|
||
},
|
||
kinds: {
|
||
query: "Query",
|
||
data_change: "Modifica dati",
|
||
schema_change: "Modifica schema",
|
||
import: "Importazione",
|
||
transfer: "Trasferimento",
|
||
redis_command: "Comando Redis",
|
||
},
|
||
kindShort: {
|
||
query: "SQL",
|
||
data_change: "Dati",
|
||
schema_change: "DDL",
|
||
import: "Importa",
|
||
transfer: "Sposta",
|
||
redis_command: "Redis",
|
||
},
|
||
detail: {
|
||
kind: "Tipo",
|
||
operation: "Operazione",
|
||
connection: "Connessione",
|
||
database: "Database",
|
||
target: "Destinazione",
|
||
time: "Ora",
|
||
duration: "Durata",
|
||
affectedRows: "Righe interessate",
|
||
rollback: "Rollback",
|
||
status: "Stato",
|
||
error: "Errore",
|
||
},
|
||
},
|
||
dangerDialog: {
|
||
title: "Operazione Pericolosa",
|
||
message: "Questa istruzione SQL potrebbe modificare o eliminare i dati in modo irreversibile. Sei sicuro di volerla eseguire?",
|
||
redisCommandMessage: "Questo comando Redis può modificare i dati e non può essere annullato automaticamente. Continuare?",
|
||
suppressFuturePrompts: "Non chiedere più per SQL pericolosi",
|
||
wrapLines: "Attiva/disattiva ritorno a capo",
|
||
deleteMessage: "Questa operazione di eliminazione potrebbe essere irreversibile. Continuare?",
|
||
deleteConfirm: "Conferma Eliminazione",
|
||
deleteRowMessage: "Questa riga verrà contrassegnata per l'eliminazione e rimossa dal database dopo il salvataggio. Continuare?",
|
||
deleteRowsMessage: "Queste {count} righe verranno contrassegnate per l'eliminazione e rimosse dal database dopo il salvataggio. Continuare?",
|
||
deleteRowDetails: "Tabella: {table}",
|
||
deleteRowDetailsNoTable: "Riga del risultato corrente",
|
||
redisKeyDetails: "Chiave Redis: {key}",
|
||
redisHashFieldDetails: "Hash Redis: {key}\nCampo: {field}",
|
||
redisListItemDetails: "Lista Redis: {key}\nIndice: {index}",
|
||
redisSetMemberDetails: "Set Redis: {key}\nMembro: {member}",
|
||
mongoDocumentDetails: "Collezione MongoDB: {collection}\n_id Documento: {id}",
|
||
mongoFieldDetails: "Campo: {field}",
|
||
mongoArrayItemDetails: "Indice elemento array: {index}",
|
||
cancel: "Annulla",
|
||
confirm: "Esegui",
|
||
},
|
||
sqlParameters: {
|
||
title: "Parametri SQL",
|
||
description: "Compila i valori per i segnaposto del template SQL. DBX li sostituisce prima di eseguire l'SQL.",
|
||
name: "Parametro",
|
||
syntax: "Sintassi",
|
||
type: "Tipo",
|
||
value: "Valore",
|
||
valuePlaceholder: "Inserisci valore",
|
||
preview: "Anteprima SQL",
|
||
execute: "Esegui",
|
||
kind: {
|
||
string: "Stringa",
|
||
number: "Numero",
|
||
boolean: "Booleano",
|
||
null: "NULL",
|
||
raw: "SQL grezzo",
|
||
},
|
||
},
|
||
transfer: {
|
||
title: "Trasferimento Dati",
|
||
source: "Sorgente",
|
||
target: "Destinazione",
|
||
sourceConnection: "Connessione Sorgente",
|
||
sourceDatabase: "Database Sorgente",
|
||
sourceSchema: "Schema Sorgente",
|
||
targetConnection: "Connessione Destinazione",
|
||
targetDatabase: "Database Destinazione",
|
||
targetSchema: "Schema Destinazione",
|
||
tables: "Tabelle",
|
||
selectAll: "Seleziona Tutto",
|
||
deselectAll: "Deseleziona Tutto",
|
||
createTable: "Crea tabella se non esiste",
|
||
transferMode: "Modalità trasferimento",
|
||
modeAppend: "Accoda (INSERT)",
|
||
modeOverwrite: "Sovrascrivi (TRUNCATE + INSERT)",
|
||
modeUpsert: "Aggiorna/Inserisci (INSERT o UPDATE per chiave primaria)",
|
||
targetTableNameCase: "Maiuscole/minuscole tabella destinazione",
|
||
tableNameCasePreserve: "Mantieni",
|
||
tableNameCaseLower: "Converti in minuscolo",
|
||
tableNameCaseUpper: "Converti in maiuscolo",
|
||
batchSize: "Dimensione lotto",
|
||
start: "Avvia Trasferimento",
|
||
cancel: "Annulla",
|
||
progress: "Trasferimento in corso...",
|
||
transferring: "Trasferimento di {table}...",
|
||
completed: "Trasferimento completato",
|
||
completedWithErrors: "Completato con {count} tabella non riuscita | Completato con {count} tabelle non riuscite",
|
||
failed: "Trasferimento non riuscito",
|
||
cancelled: "Trasferimento annullato",
|
||
rowsTransferred: "{count} righe trasferite",
|
||
tableProgress: "{current} / {total} tabelle",
|
||
noSqlConnections: "Nessuna connessione SQL disponibile",
|
||
selectTables: "Seleziona le tabelle da trasferire",
|
||
searchTables: "Cerca tabelle...",
|
||
noTables: "Nessuna tabella",
|
||
selectSourceFirst: "Seleziona prima la connessione e il database sorgente",
|
||
tableError: "Tabella {table} non riuscita: {error}",
|
||
overallProgress: "Progresso complessivo",
|
||
dataTransfer: "Trasferimento Dati",
|
||
runInBackground: "Esegui in background",
|
||
newTask: "Nuovo trasferimento",
|
||
editConfig: "Modifica config",
|
||
retry: "Riprova",
|
||
targetTableBusy: "Un altro trasferimento sta gia scrivendo le tabelle di destinazione: {tables}",
|
||
ownershipTitle: "Conferma proprietario",
|
||
ownershipMessage: "Nel database di destinazione mancano questi utenti o ruoli proprietari: {owners}. Applicare il proprietario originale potrebbe non riuscire.",
|
||
ownershipSkipDetails: "Salta non eseguirà le istruzioni di modifica del proprietario degli oggetti. I dati delle tabelle e le altre strutture continueranno a essere sincronizzati.",
|
||
ownershipTargetOwner: "Conferma riassegnerà gli oggetti con proprietari mancanti all'utente della connessione di destinazione: {owner}.",
|
||
ownershipSkip: "Salta",
|
||
ownershipConfirm: "Conferma",
|
||
selectConnection: "Seleziona connessione",
|
||
selectDatabase: "Seleziona database",
|
||
selectSchema: "Seleziona schema",
|
||
searchConnection: "Cerca connessioni...",
|
||
searchDatabase: "Cerca database...",
|
||
searchSchema: "Cerca schemi...",
|
||
},
|
||
tableImport: {
|
||
title: "Importa Dati Tabella",
|
||
target: "Tabella di destinazione",
|
||
selectFile: "Seleziona File",
|
||
changeFile: "Change File",
|
||
noFileSelected: "No file selected",
|
||
sourceFile: "Source file",
|
||
sourceFormat: "Source format",
|
||
stepSource: "Source",
|
||
stepOptions: "Options",
|
||
stepMapping: "Mapping",
|
||
stepReview: "Review",
|
||
stepExecution: "Run",
|
||
formatCsv: "CSV",
|
||
formatCsvDescription: "Comma-separated text",
|
||
formatTsv: "TSV",
|
||
formatTsvDescription: "Tab-separated text",
|
||
formatDelimited: "Delimited",
|
||
formatDelimitedDescription: "Custom text delimiter",
|
||
formatJson: "JSON",
|
||
formatJsonDescription: "Object or array rows",
|
||
formatExcel: "Excel",
|
||
formatExcelDescription: "XLS, XLSX, XLSM",
|
||
previewRows: "Preview rows",
|
||
delimiter: "Delimiter",
|
||
encoding: "Codifica",
|
||
encodingAuto: "Rilevamento automatico",
|
||
encodingUtf8: "UTF-8",
|
||
encodingGbk: "GBK / GB18030",
|
||
encodingUtf16Le: "UTF-16 LE",
|
||
encodingUtf16Be: "UTF-16 BE",
|
||
encodingDetected: "Rilevata: {encoding}",
|
||
hasHeader: "First row is header",
|
||
trimValues: "Trim values",
|
||
emptyStringAsNull: "Empty string as NULL",
|
||
jsonShape: "JSON rows",
|
||
jsonShapeAuto: "Auto-detect",
|
||
jsonShapeObjects: "Objects",
|
||
jsonShapeArrays: "Arrays",
|
||
sheet: "Sheet",
|
||
firstSheet: "First sheet",
|
||
loadPreview: "Load Preview",
|
||
reloadPreview: "Reload Preview",
|
||
previewReady: "{rows} rows, {columns} columns",
|
||
file: "File",
|
||
rows: "Righe",
|
||
mapped: "Mappata",
|
||
mapping: "Mappatura Colonne",
|
||
sourceColumn: "Origine",
|
||
targetColumn: "Destinazione",
|
||
targetDataType: "Tipo",
|
||
createColumns: "Colonne da creare",
|
||
skipColumn: "Salta",
|
||
preview: "Anteprima",
|
||
mode: "Modalità importazione",
|
||
append: "Accoda dati",
|
||
truncate: "Tronca quindi importa",
|
||
progress: "Progresso",
|
||
start: "Avvia Importazione",
|
||
success: "Importate {count} righe",
|
||
back: "Back",
|
||
next: "Next",
|
||
truncateWarning: "Existing rows in the target table will be removed before import starts.",
|
||
requiredUnmapped: "Required target columns are not mapped: {columns}",
|
||
status_idle: "Ready to import",
|
||
status_running: "Importing data",
|
||
status_done: "Import complete",
|
||
status_error: "Import failed",
|
||
status_cancelled: "Import cancelled",
|
||
},
|
||
dataGenerate: {
|
||
title: "Generazione dati",
|
||
target: "Destinazione",
|
||
rowCount: "Righe da generare",
|
||
columns: "Colonne",
|
||
column: "Colonna",
|
||
type: "Tipo",
|
||
generator: "Generatore",
|
||
columnProps: "Proprietà colonna",
|
||
databaseObjects: "Oggetti database",
|
||
selectTable: "Seleziona una tabella a sinistra",
|
||
saveProfile: "Salva profilo",
|
||
loadProfile: "Carica profilo",
|
||
options: "Opzioni",
|
||
generateOrder: "Ordine generazione",
|
||
nextStep: "Avanti",
|
||
insertSuccess: "{count} righe inserite",
|
||
noData: "No data yet, please configure generation rules first",
|
||
noResult: "No execution results",
|
||
regenerate: "Rigenera",
|
||
first50Rows: "Mostra le prime 50 righe, totale {count} righe",
|
||
resultTitle: "Risultati esecuzione",
|
||
successLabel: "{count} riuscite",
|
||
failLabel: "{count} non riuscite",
|
||
totalLabel: "/ {count} righe",
|
||
copyAllSql: "Copia tutto SQL",
|
||
prevStep: "Precedente",
|
||
startInsert: "Avvia inserimento",
|
||
confirm: "Conferma",
|
||
back: "Indietro",
|
||
reset: "Reimposta",
|
||
selectGenerator: "Select a generator...",
|
||
selectGeneratorHint: "Please select a generator",
|
||
preview: "Anteprima",
|
||
noValue: "(nessuno)",
|
||
startDate: "Start Date",
|
||
endDate: "End Date",
|
||
allDay: "All day",
|
||
startTime: "Start Time",
|
||
endTime: "End Time",
|
||
weekday: "Weekday",
|
||
all: "All",
|
||
weekdayOnly: "Weekdays",
|
||
custom: "Custom",
|
||
values: "Values",
|
||
min: "Min",
|
||
max: "Max",
|
||
increment: "Incremento",
|
||
cycle: "Cycle when exceeded",
|
||
includeDefault: "Include DEFAULT",
|
||
includeNull: "Include NULL",
|
||
unique: "Set unique",
|
||
disableLinks: "Disable data links between columns",
|
||
imageMode: "Mode",
|
||
generate: "Generate",
|
||
fromFolder: "From folder",
|
||
imageWidth: "Image Width",
|
||
imageHeight: "Image Height",
|
||
imageFormat: "Image Format",
|
||
folderPath: "Folder Path",
|
||
filterByExtension: "Filter by extensions",
|
||
errorContinue: "Continue on error",
|
||
truncateBefore: "Truncate table before generation",
|
||
useTransaction: "Use transaction",
|
||
extendedInsert: "Use extended INSERT",
|
||
ok: "OK",
|
||
noTablesSelected: "No tables selected",
|
||
orderHint: "Use arrow buttons to reorder",
|
||
gen: {
|
||
general: "General",
|
||
personal: "Personal",
|
||
payment: "Payment",
|
||
business: "Business",
|
||
location: "Location",
|
||
product: "Product",
|
||
computer: "Computer",
|
||
number: "Number",
|
||
datetime: "Date Time",
|
||
date: "Date",
|
||
time: "Time",
|
||
sequence: "Sequence",
|
||
enum: "Enum",
|
||
text: "Text",
|
||
image: "Image or Binary",
|
||
foreign_key: "Foreign Key",
|
||
uuid: "UUID",
|
||
regex: "Regex",
|
||
full_name: "Full Name",
|
||
gender: "Gender",
|
||
title: "Title",
|
||
marital_status: "Marital Status",
|
||
phone: "Phone",
|
||
email: "Email",
|
||
job_title: "Job Title",
|
||
social_id: "Social ID",
|
||
payment_method: "Payment Method",
|
||
credit_card_type: "Credit Card Type",
|
||
credit_card_number: "Credit Card Number",
|
||
credit_card_date: "Credit Card Date",
|
||
company_name: "Company Name",
|
||
department: "Department",
|
||
industry: "Industry",
|
||
address: "Address",
|
||
city: "City",
|
||
region: "Region",
|
||
product_name: "Product Name",
|
||
product_category: "Product Category",
|
||
color: "Color",
|
||
size: "Size",
|
||
weight_unit: "Weight Unit",
|
||
barcode: "Barcode",
|
||
sku: "SKU",
|
||
ip_address: "IP Address",
|
||
mac_address: "MAC Address",
|
||
file_path: "File Path",
|
||
file_name: "File Name",
|
||
file_extension: "File Extension",
|
||
url: "URL",
|
||
hostname: "Hostname",
|
||
id_number: "Numero documento",
|
||
},
|
||
idTypes: {
|
||
title: "Tipo documento",
|
||
customPattern: "Pattern personalizzato",
|
||
customPatternPlaceholder: "es. ([A-Z]{2})-([0-9]{8})",
|
||
customPatternHint: "Supporta pattern semplici come [A-Z] lettere, [0-9] cifre, {n} ripetizioni, trattini",
|
||
id_card: "Carta d'identità cinese",
|
||
passport: "Passaporto",
|
||
hk_macau_pass: "Permesso HK/Macao",
|
||
taiwan_pass: "Permesso Taiwan",
|
||
uscc: "Codice sociale unificato",
|
||
bank_card: "Carta bancaria",
|
||
drivers_license: "Patente di guida",
|
||
custom: "Personalizzato",
|
||
},
|
||
},
|
||
tableToolbox: {
|
||
title: "Strumenti dati",
|
||
generateData: "Genera dati",
|
||
importData: "Importa dati",
|
||
exportData: "Esporta dati",
|
||
generateDataComingSoon: "Prossimamente",
|
||
},
|
||
sqlFile: {
|
||
title: "Esegui File SQL",
|
||
file: "File",
|
||
selectSqlFile: "Seleziona file SQL",
|
||
browse: "Sfoglia",
|
||
previewingLines: "Anteprima di {count} righe",
|
||
previewingFirstLines: "Anteprima delle prime {count} righe",
|
||
target: "Destinazione",
|
||
connection: "Connessione",
|
||
selectConnection: "Seleziona connessione",
|
||
database: "Database",
|
||
selectDatabase: "Seleziona database",
|
||
databasePlaceholder: "Nome database",
|
||
options: "Opzioni",
|
||
continueOnError: "Continua in caso di errore",
|
||
runInBackground: "Esegui in background",
|
||
cancelling: "Annullamento in corso...",
|
||
cancel: "Annulla",
|
||
execute: "Esegui",
|
||
statement: "Istruzione",
|
||
succeeded: "Riuscito",
|
||
failed: "Non riuscito",
|
||
affectedRows: "Righe interessate",
|
||
currentStatement: "Istruzione corrente",
|
||
status: {
|
||
idle: "Inattivo",
|
||
started: "Avviato",
|
||
running: "In esecuzione",
|
||
statementDone: "Istruzione completata",
|
||
statementFailed: "Istruzione non riuscita",
|
||
done: "Completato",
|
||
error: "Errore",
|
||
cancelled: "Annullato",
|
||
},
|
||
},
|
||
diff: {
|
||
title: "Confronta Schemi",
|
||
source: "Sorgente",
|
||
target: "Destinazione",
|
||
selectConnection: "Seleziona connessione",
|
||
selectDatabase: "Seleziona database",
|
||
selectSchema: "Seleziona schema",
|
||
connection: "Connessione",
|
||
database: "Database",
|
||
schema: "Schema",
|
||
recentConfigs: "Configurazioni Recenti",
|
||
selectRecentConfig: "Seleziona configurazione recente",
|
||
ignoreComments: "Ignora differenze nei commenti",
|
||
compare: "Confronta",
|
||
comparing: "Confronto degli schemi...",
|
||
noDifferences: "Nessuna differenza trovata",
|
||
table: "Tabella",
|
||
status: "Stato",
|
||
details: "Dettagli",
|
||
added: "Aggiunta",
|
||
removed: "Rimossa",
|
||
modified: "Modificata",
|
||
indexes: "Indici",
|
||
foreignKeys: "Chiavi esterne",
|
||
triggers: "Trigger",
|
||
comments: "Commenti",
|
||
newTable: "Nuova tabella",
|
||
dropTable: "Elimina tabella",
|
||
generatedSql: "SQL di Sincronizzazione",
|
||
copySql: "Copia SQL",
|
||
executeSync: "Esegui Sincronizzazione",
|
||
syncSuccess: "Sincronizzazione eseguita con successo",
|
||
swap: "Inverti sorgente e destinazione",
|
||
syncProgress: "Esecuzione in corso: {current}/{total}",
|
||
syncSummary: "Riuscite {success}, non riuscite {failed}",
|
||
configSaved: "Configurazione salvata",
|
||
configDeleted: "Configurazione eliminata",
|
||
sourceObject: "Oggetto sorgente",
|
||
targetObject: "Oggetto destinazione",
|
||
operation: "Operazione",
|
||
selectedCount: "{selected} selezionati di {total}",
|
||
saveConfig: "Salva configurazione",
|
||
loadConfig: "Carica configurazione",
|
||
options: "Opzioni",
|
||
ddlCompare: "Confronto DDL",
|
||
deployScript: "Script di deploy",
|
||
deployScriptAll: "Tutti gli script di deploy",
|
||
deployScriptDesc: "Script SQL per l'oggetto selezionato",
|
||
deployScriptAllDesc: "Script SQL per tutti gli oggetti selezionati",
|
||
copy: "Copia",
|
||
execute: "Esegui",
|
||
executeAll: "Esegui tutto",
|
||
executeSuccess: "Eseguito con successo",
|
||
selectObjectToCompare: "Seleziona un oggetto per visualizzare il confronto DDL",
|
||
noDdlAvailable: "Nessun DDL disponibile",
|
||
noDeployScript: "Nessuno script di deploy",
|
||
noDeployScriptAll: "Nessuno script di deploy per gli oggetti selezionati",
|
||
sourceDdl: "DDL Sorgente",
|
||
targetDdl: "DDL Destinazione",
|
||
objectNotExistsInSource: "Questo oggetto non esiste nel database sorgente",
|
||
objectNotExistsInTarget: "Questo oggetto non esiste nel database di destinazione",
|
||
nextStepDeploy: "Avanti (Revisiona Deploy)",
|
||
deployReview: "Revisione Deploy",
|
||
backToResult: "Torna al Risultato",
|
||
copyScript: "Copia Script",
|
||
exportSql: "Esporta .sql",
|
||
deployToServer: "Distribuisci sul Server",
|
||
deployConfirmTitle: "Conferma Finale",
|
||
deployConfirmMessage: "Stai per distribuire le seguenti modifiche al database di destinazione",
|
||
targetServer: "Server Destinazione",
|
||
dbVersion: "Versione Database",
|
||
targetDatabase: "Database Destinazione",
|
||
targetSchema: "Schema Destinazione",
|
||
useTransaction: "Esegui in transazione (rollback automatico in caso di errore)",
|
||
confirmDeploy: "Conferma Deploy",
|
||
exportSuccess: "Esportazione riuscita",
|
||
create: "Crea",
|
||
delete: "Elimina",
|
||
modify: "Modifica",
|
||
cancel: "Annulla",
|
||
prevStep: "Precedente",
|
||
recompare: "Confronta di nuovo",
|
||
maximize: "Massimizza",
|
||
restore: "Ripristina",
|
||
operationLabel: {
|
||
modify: "Oggetti da modificare",
|
||
create: "Oggetti da creare",
|
||
delete: "Oggetti da eliminare",
|
||
none: "Nessuna operazione",
|
||
},
|
||
objectKindLabel: {
|
||
table: "Tabella",
|
||
view: "Vista",
|
||
function: "Funzione",
|
||
sequence: "Sequenza",
|
||
rule: "Regola",
|
||
owner: "Proprietario",
|
||
index: "Indice",
|
||
foreignKey: "Chiave Esterna",
|
||
trigger: "Trigger",
|
||
},
|
||
noObjectsSelected: "Seleziona gli oggetti da distribuire",
|
||
deploySuccess: "Deploy Riuscito",
|
||
deployFailed: "Deploy Non Riuscito",
|
||
deploySuccessMessage: "Script SQL eseguito con successo sul database di destinazione",
|
||
deployFailedMessage: "Si e verificato un errore durante l'esecuzione",
|
||
affectedRows: "Righe Interessate",
|
||
executedStatements: "Istruzioni Eseguite",
|
||
serverVersion: "Versione Server",
|
||
info: "Info",
|
||
connType: "Tipo connessione",
|
||
connName: "Nome connessione",
|
||
host: "Host",
|
||
port: "Porta",
|
||
copied: "Copiato negli appunti",
|
||
saveConfigPrompt: "Inserisci nome configurazione:",
|
||
close: "Chiudi",
|
||
searchConnection: "Cerca connessioni...",
|
||
searchDatabase: "Cerca database...",
|
||
searchSchema: "Cerca schemi...",
|
||
},
|
||
schemaDiff: {
|
||
optionsTitle: "Opzioni di Confronto",
|
||
selectConfig: "Seleziona configurazione",
|
||
newConfigName: "Nuova Configurazione",
|
||
newConfig: "Nuova Configurazione",
|
||
renameConfig: "Rinomina Configurazione",
|
||
duplicateConfig: "Duplica Configurazione",
|
||
deleteConfig: "Elimina Configurazione",
|
||
exportConfig: "Esporta Configurazione",
|
||
exportAllConfigs: "Esporta Tutte le Configurazioni",
|
||
importConfig: "Importa Configurazione",
|
||
importFromFile: "Importa da File",
|
||
importFromText: "Importa da Testo",
|
||
importPlaceholder: "Incolla configurazione JSON...",
|
||
importInvalidJson: "Formato JSON non valido",
|
||
configName: "Nome Configurazione",
|
||
tableFilter: "Filtro tabella",
|
||
tableFilterHint: "Corrisponde ai nomi completi delle tabelle con regex. Non digitare /.../. ^ indica inizia con, $ indica finisce con, | indica o.",
|
||
tableFilterHintShort: "Limita confronto con regex nome tabella",
|
||
tableFilterHelp: "Aiuto filtro tabella",
|
||
tableFilterHelpRule: "Corrisponde ai nomi completi delle tabelle. Non digitare /.../.",
|
||
tableFilterHelpBlank: "Includi vuoto significa tutte le tabelle. Salta vuoto significa nessuna esclusione.",
|
||
tableFilterHelpExample: "^user_ significa inizia con user_; _bak$ significa finisce con _bak; a|b significa a o b.",
|
||
tableIncludePattern: "Confronta solo tabelle corrispondenti",
|
||
tableIncludePatternPlaceholder: "es. ^utente_",
|
||
tableExcludePattern: "Salta tabelle corrispondenti",
|
||
tableExcludePatternPlaceholder: "es. _bak$",
|
||
tableFilterPriority: "Quando entrambi corrispondono",
|
||
tableFilterPriorityExclude: "Escludi prevale",
|
||
tableFilterPriorityInclude: "Includi prevale",
|
||
options: {
|
||
tables: "Confronta tabelle",
|
||
primaryKeys: "Confronta chiavi primarie",
|
||
foreignKeys: "Confronta chiavi esterne",
|
||
uniqueKeys: "Confronta chiavi univoche",
|
||
checks: "Confronta vincoli check",
|
||
exclusions: "Confronta vincoli di esclusione",
|
||
views: "Confronta viste",
|
||
functions: "Confronta funzioni",
|
||
indexes: "Confronta indici",
|
||
sequences: "Confronta sequenze",
|
||
triggers: "Confronta trigger",
|
||
rules: "Confronta regole",
|
||
owners: "Confronta proprietari",
|
||
cascadeDelete: "Usa CASCADE delete",
|
||
sequenceLastValues: "Confronta ultimi valori sequenza",
|
||
compareColumnOrder: "Confronta ordine colonne",
|
||
},
|
||
},
|
||
dataCompare: {
|
||
title: "Confronta Dati",
|
||
selectTable: "Seleziona tabella",
|
||
searchTable: "Cerca tabelle...",
|
||
sourceTables: "Tabelle sorgente",
|
||
targetTable: "Tabella di destinazione",
|
||
searchTables: "Cerca tabelle...",
|
||
selectedTables: "{selected}/{total} selezionate",
|
||
selectAllTables: "Seleziona tutte",
|
||
deselectAllTables: "Deseleziona tutte",
|
||
selectSourceTables: "Seleziona prima la connessione e il database sorgente, quindi scegli le tabelle da confrontare",
|
||
noTables: "Nessuna tabella disponibile per il confronto",
|
||
autoMatchHint: "La modalità batch associa automaticamente le tabelle di destinazione con lo stesso nome",
|
||
matchedTables: "{matched}/{total} tabelle associate",
|
||
missingTargetTables: "Tabelle di destinazione con lo stesso nome mancanti: {tables}",
|
||
keyColumns: "Colonne Chiave",
|
||
keyColumnsPlaceholder: "Colonne primarie o uniche separate da virgola",
|
||
keyColumnsAutoHint: "Lascia vuoto per rilevare automaticamente le chiavi primarie per il confronto a tabella singola, o per tabella nel confronto batch.",
|
||
rowCounts: "Sorgente {source} righe, destinazione {target} righe; confronto completo completato",
|
||
previewLimitOption: "Anteprima {count}",
|
||
compare: "Confronta Dati",
|
||
summary: "Aggiunte {added}, rimosse {removed}, modificate {modified}",
|
||
batchSummary: "Confrontate {tables} tabelle: {different} diverse, {same} identiche, {failed} non riuscite; aggiunte {added}, rimosse {removed}, modificate {modified}",
|
||
comparingTable: "Confronto di {current}/{total}: {table}",
|
||
keyColumnsInline: "Colonne chiave: {columns}",
|
||
selectedInline: "Selezionate {selected}/{total}",
|
||
selectedSummary: "Selezionate: aggiunte {added}, rimosse {removed}, modificate {modified}",
|
||
selectAllKind: "Seleziona tutti i {kind}",
|
||
clearKind: "Cancella {kind}",
|
||
clearSelection: "Cancella tutte le selezioni",
|
||
showAllRows: "Mostra tutte le {count}",
|
||
showLessRows: "Mostra meno",
|
||
remainingRows: "altre {count} righe nascoste nell'anteprima",
|
||
planningSync: "Aggiornamento del piano di sincronizzazione...",
|
||
noSelectedDifferences: "Nessuna differenza selezionata per l'esecuzione",
|
||
planSummary: "Piano: {inserts} inserimenti, {updates} aggiornamenti, {deletes} eliminazioni, {statements} istruzioni",
|
||
statusDifferent: "Diverse",
|
||
statusSame: "Identiche",
|
||
statusError: "Non riuscite",
|
||
noKeyColumns: "Seleziona almeno una colonna chiave",
|
||
missingKeyColumns: "Le colonne chiave devono esistere sia nella tabella sorgente che in quella di destinazione: {columns}",
|
||
noCommonColumns: "Le tabelle sorgente e destinazione non hanno colonne comuni da confrontare",
|
||
targetTableMissing: "Tabella di destinazione non trovata: {table}",
|
||
noComparableTables: "Nessuna tabella confrontabile trovata. Verifica se esistono tabelle di destinazione con lo stesso nome.",
|
||
noDifferences: "I dati sono identici, nessun SQL di sincronizzazione necessario",
|
||
syncSuccess: "Sincronizzazione dei dati eseguita con successo",
|
||
},
|
||
settings: {
|
||
title: "Impostazioni",
|
||
editorTab: "Editor",
|
||
sqlFormatterTab: "Formattatore SQL",
|
||
sqlFormatterImport: "Importa configurazione",
|
||
sqlFormatterExport: "Esporta configurazione",
|
||
sqlFormatterImportSuccess: "Configurazione del formattatore importata.",
|
||
sqlFormatterCopyJson: "Copia JSON",
|
||
sqlFormatterCopyJsonSuccess: "JSON copiato.",
|
||
sqlFormatterCopyJsonFailed: "Copia non riuscita: {message}",
|
||
sqlFormatterJsonEditorLoadFailed: "Impossibile caricare l'editor JSON. Uso di un input di base: {message}",
|
||
sqlFormatterRestoreDefaults: "Ripristina predefiniti",
|
||
sqlFormatterFormMode: "Modulo",
|
||
sqlFormatterJsonMode: "JSON",
|
||
sqlFormatterKeywordCase: "Maiuscole/minuscole parole chiave",
|
||
sqlFormatterFunctionCase: "Maiuscole/minuscole funzioni",
|
||
sqlFormatterDataTypeCase: "Maiuscole/minuscole tipi di dati",
|
||
sqlFormatterIdentifierCase: "Maiuscole/minuscole identificatori",
|
||
sqlFormatterCaseUpper: "Maiuscolo",
|
||
sqlFormatterCaseLower: "Minuscolo",
|
||
sqlFormatterCasePreserve: "Mantieni",
|
||
sqlFormatterIndent: "Rientro",
|
||
sqlFormatterIndentSpaces: "Spazi",
|
||
sqlFormatterIndentTabs: "Tabulazioni",
|
||
sqlFormatterTabWidth: "Larghezza tab",
|
||
sqlFormatterIndentStyle: "Stile rientro",
|
||
sqlFormatterIndentStyleStandard: "Standard",
|
||
sqlFormatterIndentStyleTabularLeft: "Tabellare sinistra",
|
||
sqlFormatterIndentStyleTabularRight: "Tabellare destra",
|
||
sqlFormatterLogicalOperatorNewline: "Nuova riga operatore logico",
|
||
sqlFormatterLogicalBefore: "Prima dell'operatore",
|
||
sqlFormatterLogicalAfter: "Dopo l'operatore",
|
||
sqlFormatterExpressionWidth: "Larghezza espressione",
|
||
sqlFormatterLinesBetweenQueries: "Righe tra query",
|
||
sqlFormatterDenseOperators: "Operatori compatti",
|
||
sqlFormatterNewlineBeforeSemicolon: "Punto e virgola su nuova riga",
|
||
sqlFormatterAdvancedOptions: "Opzioni avanzate",
|
||
sqlFormatterParams: "Parametri",
|
||
sqlFormatterParamTypes: "Tipi parametro",
|
||
sqlFormatterEditorShortcuts: "Scorciatoie",
|
||
sqlFormatterShortcutAction: "Azione",
|
||
sqlFormatterShortcutEnabled: "Attiva",
|
||
sqlFormatterShortcutWindows: "Windows",
|
||
sqlFormatterShortcutLinux: "Linux",
|
||
sqlFormatterShortcutMacos: "macOS",
|
||
sqlFormatterShortcutFind: "Trova",
|
||
sqlFormatterShortcutReplace: "Sostituisci",
|
||
sqlFormatterShortcutIndentMore: "Aumenta rientro",
|
||
sqlFormatterShortcutIndentLess: "Riduci rientro",
|
||
sqlFormatterShortcutDuplicateLine: "Duplica riga corrente",
|
||
sqlFormatterShortcutDeleteLine: "Elimina riga corrente",
|
||
sqlFormatterShortcutMoveLine: "Sposta riga",
|
||
sqlFormatterShortcutMoveLineUp: "Sposta riga su",
|
||
sqlFormatterShortcutMoveLineDown: "Sposta riga giù",
|
||
sqlFormatterShortcutCopyLine: "Copia riga",
|
||
sqlFormatterShortcutCopyLineUp: "Copia riga su",
|
||
sqlFormatterShortcutCopyLineDown: "Copia riga giù",
|
||
sqlFormatterShortcutUndo: "Annulla",
|
||
sqlFormatterShortcutRedo: "Ripeti",
|
||
sqlFormatterShortcutSelectAll: "Seleziona tutto",
|
||
sqlFormatterShortcutFormatJson: "Formatta JSON",
|
||
sqlFormatterShortcutApply: "Applica configurazione",
|
||
sqlFormatterConfigErrorInvalidJson: "JSON non valido.",
|
||
sqlFormatterConfigErrorObject: "La configurazione deve essere un oggetto JSON.",
|
||
sqlFormatterConfigErrorVersion: "Versione configurazione non supportata.",
|
||
sqlFormatterConfigErrorFormatter: "Formattatore non supportato.",
|
||
sqlFormatterConfigErrorUnsupportedParams: "La sostituzione params non è supportata. La formattazione SQL non sostituirà i segnaposto.",
|
||
sqlFormatterConfigErrorOptionsObject: "Le opzioni di configurazione devono essere un oggetto JSON.",
|
||
sqlFormatterConfigErrorEditorObject: "La configurazione dell'editor deve essere un oggetto JSON.",
|
||
sqlFormatterConfigErrorEditorScope: "Ambito editor non supportato.",
|
||
sqlFormatterConfigErrorEditorPlatforms: "Piattaforme editor non valide.",
|
||
sqlFormatterConfigErrorEditorShortcutsArray: "Le scorciatoie editor devono essere un array.",
|
||
sqlFormatterConfigErrorEditorShortcutValue: "Scorciatoia editor non valida.",
|
||
sqlFormatterConfigErrorUnknownOption: "Opzione del formattatore sconosciuta: {option}.",
|
||
sqlFormatterConfigErrorInvalidOptionValue: "Valore non valido per {option}.",
|
||
sqlFormatterConfigErrorUnknownEditorShortcut: "Scorciatoia editor sconosciuta: {shortcut}.",
|
||
sqlFormatterConfigErrorInvalidEditorShortcut: "Scorciatoia editor non valida: {shortcut}.",
|
||
sqlFormatterConfigErrorDuplicateEditorShortcut: "Scorciatoia editor duplicata: {shortcut}.",
|
||
sqlFormatterConfigErrorInvalidConfig: "Configurazione del formattatore non valida.",
|
||
appearanceTab: "Aspetto",
|
||
navigationTab: "Navigazione",
|
||
dataTab: "Dati",
|
||
tunnelsTab: "Tunnel",
|
||
tunnelsDescription: "Configurazioni riutilizzabili di tunnel SSH / proxy / HTTP. Configura una volta, poi seleziona il profilo dalla scheda tunnel di una connessione; le modifiche qui si applicano a tutte le connessioni che usano il profilo.",
|
||
tunnelsEmpty: "Nessun profilo tunnel. Creane uno qui, poi selezionalo nelle impostazioni tunnel di una connessione.",
|
||
tunnelsAddSsh: "Aggiungi SSH",
|
||
tunnelsAddProxy: "Aggiungi proxy",
|
||
tunnelsAddHttp: "Aggiungi tunnel HTTP",
|
||
tunnelsProfileName: "Nome profilo",
|
||
tunnelsProfileNamePlaceholder: "es. Bastion dell'ufficio",
|
||
tunnelsDelete: "Elimina",
|
||
tunnelsUnnamedProfile: "Profilo senza nome",
|
||
tunnelsSave: "Salva",
|
||
tunnelsReset: "Ripristina",
|
||
tunnelsSaved: "Profili tunnel salvati",
|
||
tunnelsSaveFailed: "Impossibile salvare i profili tunnel: {message}",
|
||
tunnelsUnsavedHint: "Modifiche non salvate",
|
||
tunnelsTest: "Prova",
|
||
tunnelsTesting: "Prova in corso...",
|
||
tunnelsTestSuccess: "Connessione tunnel SSH riuscita",
|
||
tunnelsTestFailed: "Prova del tunnel non riuscita: {message}",
|
||
redisTab: "Redis",
|
||
shortcutsTab: "Scorciatoie",
|
||
snippetsTab: "Snippet",
|
||
syncTab: "Sincronizzazione",
|
||
aiTab: "AI",
|
||
mcpTab: "MCP",
|
||
jdbcTab: "Driver JDBC",
|
||
securityTab: "Sicurezza",
|
||
aboutTab: "Informazioni",
|
||
fontFamily: "Famiglia Carattere (Font)",
|
||
uiFontFamily: "Carattere interfaccia",
|
||
uiFontAppDefault: "Predefinito DBX",
|
||
uiFontSystemDefault: "Predefinito di sistema",
|
||
uiFontFamilyDescription: "Si applica a barra strumenti, schede, barra laterale, finestre di dialogo e altra UI fuori dall'editor.",
|
||
selectFont: "Seleziona font...",
|
||
searchFont: "Cerca font...",
|
||
loadingFonts: "Caricamento font...",
|
||
noFontsFound: "Nessun font trovato",
|
||
useCustomFont: "Usa “{font}”",
|
||
languageTitle: "Lingua / Language",
|
||
fontSize: "Dimensione Carattere",
|
||
toolbarTitle: "Barra degli strumenti",
|
||
toolbarHiddenHint: "Alcuni pulsanti nascosti o in eccesso appariranno nel menu «Altro».",
|
||
uiScale: "Scala UI",
|
||
uiScaleDescription: "Scala l'intera interfaccia utente desktop per display ad alta densità (High-DPI). Le modifiche si applicano immediatamente e vengono ripristinate al prossimo avvio.",
|
||
theme: "Tema",
|
||
selectTheme: "Seleziona tema...",
|
||
colorTheme: "Tema colore",
|
||
selectColorTheme: "Seleziona tema colore...",
|
||
themePalettePearl: "Bianco",
|
||
themePaletteMist: "Grigio nebbia",
|
||
themePaletteGraphite: "Grigio titanio",
|
||
themePaletteCobalt: "Blu cobalto",
|
||
themePaletteSage: "Verde salvia",
|
||
themePaletteAmber: "Giallo caldo",
|
||
themePaletteBlush: "Rosa sakura",
|
||
themePaletteVscode: "VS Code",
|
||
themePaletteIdea: "IDEA",
|
||
themePaletteXcode: "Xcode",
|
||
themePaletteJetbrains: "JetBrains",
|
||
themePaletteCursor: "Cursor",
|
||
themePaletteClaude: "Claude Code",
|
||
followAppTheme: "Segui il tema dell'applicazione",
|
||
appLayout: "Layout dell'Interfaccia",
|
||
appLayoutSeparated: "Separato moderno",
|
||
appLayoutSeparatedDescription: "Separazione chiara dei pannelli con schede stile blocco.",
|
||
appLayoutClassic: "Classico compatto",
|
||
appLayoutClassicDescription: "Barra delle schede continua con intestazioni di pannello compatte.",
|
||
iconTheme: "Stile icona e logo",
|
||
iconThemeDefault: "Predefinito",
|
||
iconThemeDefaultDescription: "Utilizza l'icona colorata dell'app DBX.",
|
||
iconThemeBlack: "Nero",
|
||
iconThemeBlackDescription: "Usa il logo DBX nero nell'app.",
|
||
iconThemeBlackDescriptionMac: "Usa il logo nero nell'app; il Dock usa una base nera e la barra menu segue il sistema.",
|
||
showTrayIcon: "Mostra icona nella barra delle applicazioni/menu",
|
||
showTrayIconDescription: "Se disattivato, non viene mostrata alcuna icona, ma la chiusura della finestra nasconderà comunque DBX in background.",
|
||
quitOnClose: "Esci alla chiusura della finestra",
|
||
quitOnCloseDescription: "Se attivato, il pulsante di chiusura termina completamente DBX invece di nasconderlo nella barra delle applicazioni.",
|
||
closeActionPromptTitle: "Chiudi finestra",
|
||
closeActionPromptDescription: "Scegli cosa succede quando clicchi il pulsante di chiusura. Puoi modificarlo in seguito in Impostazioni → Aspetto.",
|
||
closeActionQuit: "Esci da DBX",
|
||
closeActionMinimize: "Riduci a icona",
|
||
updateNotificationsEnabled: "Abilita promemoria aggiornamenti",
|
||
updateNotificationsEnabledDescription: "Se disattivato, DBX non controllerà automaticamente gli aggiornamenti dell'app o dei driver e non mostrerà badge. I controlli manuali restano disponibili.",
|
||
updateDownloadSource: "Fonte download aggiornamenti",
|
||
updateDownloadSourceDescription: "Scegli da dove scaricare gli installer degli aggiornamenti. La fonte ufficiale è consigliata; CNB o AtomGit possono essere più veloci sulle reti della Cina continentale.",
|
||
updateDownloadSourceOfficial: "Fonte ufficiale (consigliata)",
|
||
updateDownloadSourceCnb: "CNB",
|
||
updateDownloadSourceAtomgit: "AtomGit",
|
||
debugLoggingEnabled: "Abilita log di debug",
|
||
debugLoggingEnabledDescription: "Registra log diagnostici locali lato utente durante l'analisi delle segnalazioni. Disattivato per impostazione predefinita.",
|
||
duckDbWorkerProcessIsolation: "Modalità di isolamento del processo DuckDB (sperimentale)",
|
||
duckDbWorkerProcessIsolationDescription: "Esegue le query DuckDB in un processo worker separato. Se una query lunga non risponde all'annullamento, DBX può arrestare il processo worker per rilasciare il blocco del file di database.",
|
||
duckDbWorkerMaxProcesses: "Worker DuckDB simultanei massimi",
|
||
duckDbWorkerMaxProcessesDescription: "Limita quanti processi worker DuckDB DBX può eseguire contemporaneamente. Intervallo: 1-16. Predefinito: 4.",
|
||
duckDbWorkerProcessIsolationRestartRequired: "Riavvia DBX affinché questa modifica abbia effetto.",
|
||
restartDbx: "Riavvia DBX",
|
||
restartDbxFailed: "Impossibile riavviare DBX: {error}",
|
||
debugLogsCopy: "Copia log",
|
||
debugLogsCopied: "Copiati",
|
||
debugLogsDownload: "Scarica log",
|
||
debugLogsDownloaded: "Scaricati",
|
||
debugLogsClear: "Cancella log",
|
||
tableStructureSection: "Struttura tabella",
|
||
dataGridDisplay: "Visualizzazione griglia dati",
|
||
showColumnCommentsInHeader: "Mostra i commenti delle colonne sotto i nomi",
|
||
showColumnCommentsInHeaderDescription: "Visualizza i commenti delle colonne della tabella direttamente sotto i nomi delle colonne nella griglia.",
|
||
showColumnTypesInHeader: "Mostra i tipi di colonna sotto i nomi",
|
||
showColumnTypesInHeaderDescription: "Visualizza il tipo di dato di ciascuna colonna direttamente sotto i nomi delle colonne nella griglia.",
|
||
compactColumnHeaderActions: "Strumenti intestazione colonna compatti",
|
||
compactColumnHeaderActionsDescription: "Sposta gli strumenti del formattatore e dei filtri locali in un menu 'altro' in modo che i nomi delle colonne abbiano la priorità.",
|
||
dataGridQuickEntry: "Inserimento rapido griglia",
|
||
dataGridQuickEntryDescription: "Se attivo, la modifica di una cella o la compilazione della riga vuota in fondo viene salvata nel database appena il focus esce. Utile per inserimenti frequenti, ma può causare scritture accidentali.",
|
||
infiniteScroll: "Caricamento a scorrimento infinito",
|
||
autoCalculateTotalRows: "Calcola automaticamente il totale delle righe",
|
||
autoCalculateTotalRowsDescription: "Esegue COUNT(*) automaticamente dopo ogni query per mostrare il totale delle righe corrispondenti. Disattivato per impostazione predefinita per mantenere veloci le query grandi; puoi calcolarlo all'occorrenza dal piè di pagina dei risultati.",
|
||
infiniteScrollDescription: "Carica automaticamente la pagina successiva dei dati quando scorri fino in fondo alla tabella.",
|
||
infiniteScrollMaxRows: "Righe max a scorrimento infinito",
|
||
infiniteScrollMaxRowsDescription: "Numero massimo di righe da caricare in modalità scorrimento infinito (1000–50000).",
|
||
tableColumnTemplateFields: "Campi predefiniti per nuove tabelle",
|
||
tableColumnTemplateFieldsDescription: "Scegli un tipo di database e configura i tipi dei campi predefiniti usati durante la creazione di nuove tabelle.",
|
||
tableColumnTemplateAdd: "Aggiungi campo",
|
||
tableColumnTemplateColumn: "Campo",
|
||
tableColumnTemplateDatabase: "Database",
|
||
tableColumnTemplateType: "Tipo",
|
||
tableColumnTemplateLength: "Lunghezza",
|
||
tableColumnTemplateDefault: "Valore predefinito",
|
||
tableColumnTemplateNoPresetType: "Nessun tipo preimpostato",
|
||
tableColumnTemplateRequired: "Obbligatorio",
|
||
tableColumnTemplateComment: "Descrizione",
|
||
tableColumnTemplateDragHandle: "Trascina per riordinare",
|
||
sidebarActivation: "Attivazione barra laterale",
|
||
sidebarActivationSingle: "Singolo clic",
|
||
sidebarActivationSingleDescription: "Apri gli elementi della barra laterale con un solo clic.",
|
||
sidebarActivationDouble: "Doppio clic",
|
||
sidebarActivationDoubleDescription: "Un singolo clic seleziona le righe; un doppio clic apre gli elementi.",
|
||
sidebarObjectDisplay: "Layout oggetti barra laterale",
|
||
sidebarObjectDisplayGrouped: "Vista avanzata",
|
||
sidebarObjectDisplayGroupedDescription: "Raggruppa gli oggetti per tabelle, viste, procedure e funzioni per i database con più tipi di oggetti.",
|
||
sidebarObjectDisplaySimple: "Vista semplice",
|
||
sidebarObjectDisplaySimpleDescription: "Elenca tabelle e viste direttamente sotto ogni database o schema per ridurre i livelli intermedi.",
|
||
autoSelectActiveSidebarNode: "Seleziona sempre l'elemento aperto",
|
||
autoSelectActiveSidebarNodeDescription: "Quando passi da una scheda all'altra, seleziona la tabella, la collezione o il file SQL visibile corrispondente nella barra laterale.",
|
||
openTabsRestoreMode: "Ripristina schede all'avvio",
|
||
openTabsRestoreModeDescription: "Scegli come DBX ripristina le schede aperte l'ultima volta.",
|
||
openTabsRestoreModeAll: "Mantieni tutte le schede",
|
||
openTabsRestoreModePinned: "Solo schede fissate",
|
||
openTabsRestoreModeNone: "Non mantenere schede",
|
||
openTabsRestoreModeHint: "Le schede fissate restano sul lato sinistro della barra delle schede e sono utili come punti di accesso frequenti.",
|
||
disconnectTabHandlingMode: "Schede dopo la disconnessione",
|
||
disconnectTabHandlingModeDescription: "Scegli come gestire le schede correlate dopo la chiusura di una connessione o di un database.",
|
||
disconnectTabHandlingModeCloseTabs: "Chiudi tutte le schede",
|
||
disconnectTabHandlingModeCloseTabsDescription: "Chiudi tutte le schede correlate per la connessione o il database.",
|
||
disconnectTabHandlingModeKeepTabsClearResults: "Chiudi schede oggetti, mantieni schede SQL",
|
||
disconnectTabHandlingModeKeepTabsClearResultsDescription: "Chiudi i dati delle tabelle, l'esplorazione degli oggetti e le schede della struttura mantenendo le schede delle query SQL e il testo SQL, e cancella anche lo stato di esecuzione e le sessioni dei risultati.",
|
||
disconnectTabHandlingModeKeepTabsKeepResults: "Non chiudere le schede correlate",
|
||
disconnectTabHandlingModeKeepTabsKeepResultsDescription: "Mantieni le schede correlate, il testo SQL e i risultati correnti senza ulteriore pulizia.",
|
||
reuseDataTab: "Riusa scheda dati",
|
||
reuseDataTabDescription: "Quando fai clic su una tabella nella barra laterale, riutilizza la scheda dati esistente invece di crearne una nuova ogni volta.",
|
||
sidebarHiddenTablePrefixes: "Prefissi dei nomi delle tabelle nascosti",
|
||
sidebarHiddenTablePrefixesDescription: "Un prefisso per riga. Solo le etichette di tabelle, viste e collezioni della barra laterale vengono abbreviate; i suggerimenti e le azioni utilizzano ancora il nome completo.",
|
||
sidebarHiddenTablePrefixesPlaceholder: "Esempio:\nODS_\nT8Y2_LONG_",
|
||
sidebarTablePageSize: "Dimensione pagina barra laterale",
|
||
sidebarTablePageSizeDescription: "Numero massimo di tabelle/oggetti caricati per pagina nell'albero laterale. Aumentalo se hai molte tabelle per ridurre le pagine.",
|
||
sidebarTableSearchEnabled: "Abilita ricerca tabelle nel database",
|
||
sidebarTableSearchEnabledDescription: "Mostra una casella di ricerca locale sotto database, schema o gruppi di tabelle espansi per filtrare le tabelle separatamente.",
|
||
sidebarHideTableComments: "Nascondi i commenti delle tabelle nella barra laterale",
|
||
sidebarHideTableCommentsDescription: "Nascondi i commenti in linea delle tabelle/viste mostrati accanto ai nomi nell'albero della barra laterale per risparmiare spazio orizzontale.",
|
||
sidebarAllowHorizontalScroll: "Consenti scorrimento orizzontale barra laterale",
|
||
sidebarAllowHorizontalScrollDescription: "Mostra i nomi lunghi di tabelle, viste e collezioni per intero consentendo lo scorrimento orizzontale della barra laterale.",
|
||
snippetsDescription: "Personalizza i modelli di snippet SQL attivati nell'editor.",
|
||
snippetsAdd: "Aggiungi Snippet",
|
||
snippetsLabel: "Etichetta",
|
||
snippetsPrefix: "Prefisso",
|
||
snippetsStatus: "Stato",
|
||
snippetsEnabled: "Attivo",
|
||
snippetsDisabled: "Disattivo",
|
||
snippetsToggle: "Attiva o disattiva snippet",
|
||
snippetsBody: "Corpo SQL",
|
||
snippetsLabelPlaceholder: "es. select *",
|
||
snippetsPrefixPlaceholder: "es. sel",
|
||
snippetsBodyPlaceholder: "SELECT *\nFROM tabella\nLIMIT 100;",
|
||
snippetsRestoreDefaults: "Ripristina Predefiniti",
|
||
snippetsAddTitle: "Aggiungi Snippet",
|
||
snippetsEditTitle: "Modifica Snippet",
|
||
syncWebDavTitle: "Sincronizzazione WebDAV",
|
||
syncWebDavDescription: "Carica o ripristina uno snapshot di DBX, inclusa la libreria SQL salvata, da un servizio di archiviazione compatibile con WebDAV.",
|
||
syncEndpoint: "URL WebDAV",
|
||
syncUsername: "Nome utente",
|
||
syncPassword: "Password",
|
||
syncPasswordPlaceholder: "Inserisci password",
|
||
syncClearSavedPassword: "Cancella password salvata",
|
||
syncRememberWebDavPassword: "Ricorda la password dell'app WebDAV",
|
||
syncSavedPassword: "(salvata)",
|
||
syncRememberWebDavPasswordDescription: "La password viene crittografata e memorizzata solo su questo dispositivo. Non viene sincronizzata su WebDAV e non sostituisce la password di sincronizzazione.",
|
||
syncRemotePath: "Percorso snapshot remoto",
|
||
syncRemotePathDescription: "DBX creerà le cartelle superiori mancanti durante il caricamento.",
|
||
syncSecretNotice: "Per impostazione predefinita, DBX sincronizza solo i dettagli e le impostazioni di connessione. Le password dei database, le password SSH, le password proxy, le stringhe di connessione e le chiavi API AI rimangono locali.",
|
||
syncSecrets: "Sincronizza i segreti crittografati",
|
||
syncSecretsDescription: "Se abilitato, DBX crittografa le password del database, le password SSH e le chiavi API AI prima di caricarle su WebDAV.",
|
||
syncSecretsPassphrase: "Password di sincronizzazione",
|
||
syncSecretsPassphraseDescription: "Questa password viene utilizzata solo per crittografare e ripristinare i dati sensibili. DBX non la salva; inseriscila nuovamente su ciascun dispositivo.",
|
||
syncTest: "Verifica",
|
||
syncUpload: "Carica",
|
||
syncDownload: "Scarica",
|
||
syncTestSuccess: "La destinazione WebDAV è raggiungibile.",
|
||
syncUploadSuccess: "Caricati {bytes} byte su {path}.",
|
||
syncAutoUpload: "Carica automaticamente gli snapshot",
|
||
syncAutoUploadInterval: "Ogni",
|
||
syncAutoUploadMinutes: "minuti",
|
||
syncAutoUploadDescription: "Viene eseguito mentre DBX è aperto. I download richiedono ancora conferma manuale per evitare di sostituire SQL salvati localmente.",
|
||
syncAutoUploadSuccess: "Caricati automaticamente {bytes} byte su {path}.",
|
||
syncDownloadSuccess: "Scaricati e applicati {bytes} byte da {path}.",
|
||
syncSecretsApplied: "I segreti crittografati sono stati ripristinati.",
|
||
syncSecretsSkipped: "I segreti crittografati erano presenti ma non sono stati ripristinati.",
|
||
syncDownloadConfirm: "Scaricare e applicare lo snapshot DBX remoto? I metadati locali e i file SQL salvati verranno sostituiti.",
|
||
apply: "Applica",
|
||
applyAndClose: "Applica e Chiudi",
|
||
reset: "Reimposta",
|
||
resetDefaults: "Ripristina Predefiniti",
|
||
resetAllDefaults: "Ripristina Tutti i Predefiniti",
|
||
save: "Salva",
|
||
cancel: "Annulla",
|
||
executeMode: "Modalità Esecuzione (Cmd+Enter)",
|
||
executeModeAll: "Esegui tutto l'SQL",
|
||
executeModeCurrent: "Esegui istruzione al cursore",
|
||
showExecutionTargetPicker: "Mostra selettore destinazione",
|
||
showExecutionTargetPickerDescription: "Se attivo, l'esecuzione senza selezione permette di scegliere tra istruzione corrente e tutto l'SQL.",
|
||
showStatementRunButtons: "Mostra pulsanti di esecuzione laterali",
|
||
showStatementRunButtonsDescription: "Mostra nel margine dell'editor SQL i pulsanti per eseguire ogni istruzione. Scorciatoie da tastiera e menu contestuale continuano a funzionare quando disattivati.",
|
||
showCurrentStatementFrame: "Mostra cornice istruzione corrente",
|
||
showCurrentStatementFrameDescription: "Se attivo, l'editor SQL disegna un contorno intorno all'istruzione eseguibile corrente; se disattivato, il contorno è nascosto.",
|
||
showInsertValueHints: "Mostra suggerimenti colonne nei VALUES di INSERT",
|
||
showInsertValueHintsDescription: "Se attivo, l'editor SQL mostra il nome della colonna accanto a ogni valore nelle clausole INSERT ... VALUES.",
|
||
previewStatementRunButton: "Pulsante di esecuzione istruzione in anteprima",
|
||
wordWrap: "A capo automatico",
|
||
wordWrapDescription: "Incolonna le righe SQL lunghe entro la larghezza dell'editor",
|
||
vimMode: "Modalita Vim",
|
||
vimModeDescription: "Usa la modifica modale in stile Vim nell'editor SQL",
|
||
autoCloseBrackets: "Chiusura automatica parentesi",
|
||
autoCloseBracketsDescription: "Inserisci automaticamente parentesi e virgolette di chiusura quando digiti quelle di apertura",
|
||
sqlSemanticDiagnosticsEnabled: "Diagnostica semantica SQL",
|
||
sqlSemanticDiagnosticsEnabledDescription: "Se abilitata, l'editor segnala problemi semantici come tabelle e colonne sconosciute. Disabilitala per ridurre l'analisi e i controlli dei metadati per file SQL di grandi dimensioni.",
|
||
confirmDangerousSqlExecution: "Conferma prima di SQL pericoloso",
|
||
confirmDangerousSqlExecutionDescription: "Se disattivato, ALTER, DROP, DELETE, TRUNCATE e altri SQL pericolosi verranno eseguiti senza la finestra di avviso.",
|
||
continueOnErrorOnBatch: "Continua in caso di errore",
|
||
continueOnErrorOnBatchDescription: "Se abilitato, l'esecuzione di più istruzioni continua dopo un errore invece di interrompersi al primo fallimento.",
|
||
confirmUnsavedSqlClose: "Conferma prima di chiudere SQL non salvato",
|
||
confirmUnsavedSqlCloseDescription: "Se disattivato, le schede SQL con modifiche non salvate verranno chiuse o usciranno senza la finestra di conferma di salvataggio.",
|
||
prefillNewQueryWithSelect: "Precompila nuova query con SELECT *",
|
||
prefillNewQueryWithSelectDescription: "Alla creazione di una nuova query, precompila l'editor con SELECT * FROM <tabella> in base alla scheda tabella attiva o alla tabella selezionata nella barra laterale.",
|
||
sqlVariableSyntax: "Sostituzione di variabili e segnaposto SQL",
|
||
sqlVariableSyntaxDescription: "Scegli quali sintassi di variabili e segnaposto DBX sostituisce prima di eseguire SQL, per tipo di database. Tutte abilitate per impostazione predefinita.",
|
||
sqlVariableSyntax_positional: "Segnaposto posizionale",
|
||
sqlVariableSyntax_positionalDescription: "Richiede un valore per sostituire ogni segnaposto posizionale in ordine.",
|
||
sqlVariableSyntax_named: "Segnaposto con nome",
|
||
sqlVariableSyntax_namedDescription: "Richiede un valore per sostituire i segnaposto con nome.",
|
||
sqlVariableSyntax_shell: "Segnaposto stile shell",
|
||
sqlVariableSyntax_shellDescription: "Richiede un valore per sostituire i segnaposto in stile shell.",
|
||
sqlVariableSyntax_mybatis: "Segnaposto stile MyBatis",
|
||
sqlVariableSyntax_mybatisDescription: "Richiede un valore per sostituire i segnaposto in stile MyBatis.",
|
||
sqlVariableSyntax_sqlserver: "Segnaposto stile SQL Server",
|
||
sqlVariableSyntax_sqlserverDescription: "Richiede un valore per sostituire i segnaposto in stile SQL Server (possono entrare in conflitto con le variabili di sessione).",
|
||
sqlVariableSyntax_atSet: "Espansione di variabili inline",
|
||
sqlVariableSyntax_atSetDescription: "Espande le dichiarazioni di variabili inline e ne sostituisce i valori prima dell'esecuzione.",
|
||
autoAliasTables: "Aggiungi alias tabella automaticamente",
|
||
autoAliasTablesDescription: "Quando scegli una tabella in FROM o JOIN, inserisce un alias generato come order_items AS oi.",
|
||
redisScanPageSize: "Conteggio scansione Redis",
|
||
redisScanPageSizeDescription: "Chiavi richieste per pagina SCAN di Redis durante la navigazione delle chiavi.",
|
||
redisScanPageSizeOption: "{count} chiavi",
|
||
exportBatchSize: "Dimensione del lotto di esportazione",
|
||
exportBatchSizeDescription: "Righe recuperate per lotto durante l'esportazione dei dati della tabella (100-100000).",
|
||
exportRowLimitEnabled: "Limita righe esportate",
|
||
exportRowLimitEnabledDescription: "Quando attivo, l'esportazione dei risultati di query e dei dati tabella si ferma al limite di righe sotto.",
|
||
exportRowLimit: "Limite righe esportazione dati",
|
||
exportRowLimitDescription: "Numero massimo di righe per l'esportazione dei risultati di query e dei dati tabella.",
|
||
exportRowLimitUnlimited: "Illimitato",
|
||
queryExportKeysetOptimizationEnabled: "Prova ottimizzazione keyset",
|
||
queryExportKeysetOptimizationEnabledDescription: "Si applica solo a query a tabella singola riconosciute in sicurezza; le query complesse ricadono automaticamente.",
|
||
exportSection: "Esportazione",
|
||
shortcutExecuteSql: "Esegui SQL",
|
||
shortcutFind: "Trova",
|
||
shortcutReplace: "Sostituisci",
|
||
shortcutSaveSql: "Salva SQL",
|
||
shortcutAcceptCompletion: "Accetta completamento",
|
||
shortcutFormatSql: "Formatta SQL",
|
||
shortcutToggleLineComment: "Attiva/disattiva commento di riga",
|
||
shortcutIndentMore: "Aumenta rientro",
|
||
shortcutIndentLess: "Riduci rientro",
|
||
shortcutDuplicateLine: "Duplica riga corrente",
|
||
shortcutDeleteLine: "Elimina riga corrente",
|
||
shortcutMoveLineUp: "Sposta riga su",
|
||
shortcutMoveLineDown: "Sposta riga giù",
|
||
shortcutCopyLineUp: "Copia riga su",
|
||
shortcutCopyLineDown: "Copia riga giù",
|
||
shortcutUndo: "Annulla",
|
||
shortcutRedo: "Ripeti",
|
||
shortcutSelectAll: "Seleziona tutto",
|
||
shortcutCopyCurrentRow: "Copia riga dati corrente",
|
||
shortcutDeleteCurrentRow: "Elimina riga dati corrente",
|
||
shortcutNewQuery: "Nuova query",
|
||
shortcutOpenSettings: "Apri impostazioni",
|
||
shortcutCloseTab: "Chiudi scheda",
|
||
shortcutFocusSearch: "Focalizza ricerca",
|
||
shortcutQuickOpen: "Apertura rapida (ricerca tutti gli oggetti del database)",
|
||
shortcutSwitchToPreviousTab: "Passa alla scheda precedente",
|
||
shortcutSwitchToNextTab: "Passa alla scheda successiva",
|
||
shortcutSwitchToTab1: "Passa alla scheda 1",
|
||
shortcutSwitchToTab2: "Passa alla scheda 2",
|
||
shortcutSwitchToTab3: "Passa alla scheda 3",
|
||
shortcutSwitchToTab4: "Passa alla scheda 4",
|
||
shortcutSwitchToTab5: "Passa alla scheda 5",
|
||
shortcutSwitchToTab6: "Passa alla scheda 6",
|
||
shortcutSwitchToTab7: "Passa alla scheda 7",
|
||
shortcutSwitchToTab8: "Passa alla scheda 8",
|
||
shortcutSwitchToTab9: "Passa alla scheda 9",
|
||
shortcutZoomInUi: "Ingrandisci UI",
|
||
shortcutZoomOutUi: "Rimpicciolisci UI",
|
||
shortcutResetUiZoom: "Reimposta zoom UI",
|
||
shortcutRefreshData: "Aggiorna dati",
|
||
shortcutToggleTranspose: "Attiva/disattiva vista trasposta",
|
||
shortcutCancelSearch: "Annulla ricerca",
|
||
shortcutToggleSidebar: "Attiva/disattiva barra laterale",
|
||
shortcutCopySidebarSelection: "Copia selezione barra laterale",
|
||
shortcutPasteSidebarSelection: "Incolla nella barra laterale",
|
||
shortcutEditSidebarConnection: "Modifica connessione barra laterale",
|
||
shortcutOpenDataInNewTab: "Apri dati in una nuova scheda (clic del mouse)",
|
||
shortcutSendSelectionToAi: "Invia selezione ad AI",
|
||
shortcutScopeGlobal: "Globale",
|
||
shortcutScopeEditor: "Editor SQL",
|
||
shortcutScopeGrid: "Griglia dati",
|
||
shortcutScopeSearch: "Cerca campi",
|
||
shortcutScopeSidebar: "Barra laterale",
|
||
shortcutPressShortcut: "Premi scorciatoia",
|
||
shortcutSearchPlaceholder: "Cerca scorciatoie",
|
||
shortcutSearchNoResults: "Nessuna scorciatoia corrisponde alla ricerca.",
|
||
shortcutConflict: "Questa scorciatoia è in conflitto con un'altra azione nello stesso ambito.",
|
||
shortcutClear: "Cancella scorciatoia",
|
||
preview: "Anteprima in tempo reale",
|
||
customTheme: "Tema personalizzato",
|
||
customThemeConfigure: "Configura tema personalizzato",
|
||
customThemeTitle: "Configurazione tema personalizzato",
|
||
customThemeMyThemes: "I miei temi",
|
||
customThemeNewTheme: "Nuovo tema",
|
||
customThemeVisualEdit: "Editor visuale",
|
||
customThemeJsonConfig: "Configurazione JSON",
|
||
customThemeLivePreview: "Anteprima in tempo reale",
|
||
customThemePreviewExample: "Esempio di query",
|
||
customThemePreset: "Tema predefinito",
|
||
customThemeSelectPreset: "Seleziona tema predefinito...",
|
||
customThemeApply: "Applica",
|
||
customThemePasteImport: "Importa da testo incollato",
|
||
customThemeExportJson: "Esporta JSON",
|
||
customThemeSaveAndApply: "Salva e applica",
|
||
customThemeKeyword: "Parola chiave",
|
||
customThemeField: "Campo/Variabile",
|
||
customThemeFunction: "Funzione",
|
||
customThemeString: "Stringa",
|
||
customThemeNumber: "Numero",
|
||
customThemeComment: "Commento",
|
||
customThemeTable: "Tabella",
|
||
customThemeOperator: "Operatore",
|
||
customThemeType: "Tipo",
|
||
customThemeBuiltin: "Integrato",
|
||
customThemeBackground: "Sfondo",
|
||
customThemeForeground: "Primo piano",
|
||
customThemeDefaultName: "Tema personalizzato",
|
||
customThemeCopySuffix: " Copia",
|
||
customThemeApplied: 'Schema colori "{name}" applicato',
|
||
customThemeKeepOne: "Mantieni almeno un tema",
|
||
customThemeJsonError: "Formato JSON non valido, controlla",
|
||
jdbcPlugin: "Plugin DBX JDBC",
|
||
jdbcPluginInstall: "Installa plugin JDBC",
|
||
jdbcPluginInstallSuccess: "Plugin JDBC installato",
|
||
jdbcPluginUpdate: "Aggiorna",
|
||
jdbcPluginUninstall: "Disinstalla",
|
||
jdbcPluginUninstallSuccess: "Plugin JDBC disinstallato",
|
||
jdbcPluginInstalled: "Installato: v{version}",
|
||
jdbcPluginIncompatible: "Protocollo incompatibile",
|
||
jdbcPluginNotInstalled: "Non installato",
|
||
jdbcDrivers: "JAR del driver JDBC",
|
||
jdbcImport: "Importa JAR",
|
||
jdbcImportPath: "Percorso di importazione",
|
||
jdbcDriverPathPlaceholder: "/percorso/per/driver.jar",
|
||
jdbcImportSuccess: "Importato/i {count} file del driver",
|
||
jdbcDeleteSuccess: "Driver rimosso",
|
||
jdbcNoDrivers: "Nessun driver JDBC ancora importato.",
|
||
mcpTitle: "Server MCP",
|
||
mcpDescription: "Verifica l'installazione e la versione del Server DBX MCP utilizzata da Claude Code, Cursor e altri agenti.",
|
||
mcpChecking: "Verifica in corso",
|
||
mcpStatusUnknown: "Non verificato",
|
||
mcpStatusError: "Verifica non riuscita",
|
||
mcpReady: "Pronto",
|
||
mcpNotInstalled: "Non installato",
|
||
mcpUpdateAvailable: "Aggiornamento disponibile",
|
||
mcpCurrent: "Versione corrente",
|
||
mcpLatest: "Ultima versione",
|
||
mcpVersionMissing: "Nessuna installazione globale rilevata",
|
||
mcpVersionUnknown: "Sconosciuta",
|
||
mcpAvailable: "Disponibile",
|
||
mcpUnavailable: "Non disponibile",
|
||
mcpBinPath: "Comando path",
|
||
mcpInstallCommand: "Comando di installazione",
|
||
mcpUpdateCommand: "Comando di aggiornamento",
|
||
mcpInstallButton: "Installa",
|
||
mcpUpdateButton: "Aggiorna",
|
||
mcpUpToDate: "Aggiornato",
|
||
mcpInstalling: "Installazione...",
|
||
mcpInstallSuccess: "Installazione completata",
|
||
mcpInstallFailed: "Installazione fallita",
|
||
mcpConfig: "Configurazione MCP",
|
||
mcpConfigOptionsHint: "Queste opzioni aggiornano solo la configurazione generata. Copiala nel client AI e riavvia la sessione MCP per applicarla.",
|
||
mcpCodexConfig: "Configurazione Codex",
|
||
mcpCodexConfigPath: "Codex può utilizzare ~/.codex/config.toml o un .codex/config.toml a livello di progetto.",
|
||
mcpCursorConfigPath: "Cursor può usare .cursor/mcp.json nel progetto o ~/.cursor/mcp.json globalmente.",
|
||
mcpTraeConfigPath: "TRAE: Impostazioni > MCP > Aggiungi > Aggiungi manualmente, poi incolla la configurazione JSON.",
|
||
mcpVsCodeConfigPath: "VS Code/Copilot può usare .vscode/mcp.json nell'area di lavoro o mcp.json nel profilo utente.",
|
||
mcpWindsurfConfigPath: "Windsurf può usare ~/.codeium/windsurf/mcp_config.json.",
|
||
mcpOpenCodeConfigPath: "~/.config/opencode/opencode.json globalmente, o opencode.json a livello di progetto.",
|
||
mcpReadonlyMode: "Modalità sola lettura",
|
||
mcpReadonlyModeDescription: "Aggiunge DBX_MCP_ALLOW_WRITES=0 alla configurazione di esempio in modo che la sessione MCP rimanga di sola query.",
|
||
mcpAllowDangerous: "Consenti SQL pericoloso",
|
||
mcpAllowDangerousDescription: "Aggiunge DBX_MCP_ALLOW_DANGEROUS_SQL=1 alla configurazione di esempio in modo che siano consentite istruzioni come DROP, TRUNCATE, ALTER e simili.",
|
||
mcpDetectionTiming: "DBX esegue la verifica automaticamente all'apertura di questa pagina; usa di nuovo Verifica per aggiornare.",
|
||
mcpNpmBoundary: "DBX verifica e spiega solo lo stato di MCP; l'installazione e gli aggiornamenti vengono comunque eseguiti tramite npm.",
|
||
mcpRefresh: "Verifica di nuovo",
|
||
mcpGuide: "Guida MCP",
|
||
supportInfoTitle: "Informazioni di supporto",
|
||
supportInfoDescription: "Copia questi dettagli dell'ambiente quando apri issue o chiedi aiuto.",
|
||
supportInfoCopy: "Copia informazioni",
|
||
supportInfoCopied: "Copiato",
|
||
supportInfoLoading: "Caricamento informazioni di supporto...",
|
||
supportInfoLoadFailed: "Impossibile caricare tutte le informazioni di supporto: {message}",
|
||
supportInfoAppVersion: "Versione DBX",
|
||
supportInfoRuntime: "Ambiente",
|
||
supportInfoRuntimeDesktop: "Desktop",
|
||
supportInfoRuntimeWeb: "Web",
|
||
supportInfoOperatingSystem: "Sistema operativo",
|
||
supportInfoArchitecture: "Architettura",
|
||
supportInfoUnknown: "Sconosciuto",
|
||
community: "Community",
|
||
qqGroup: "Gruppo QQ",
|
||
wechatGroup: "Gruppo WeChat",
|
||
wechatGroupInvite: "Invito Tencent Docs",
|
||
project: "Progetto",
|
||
openSource: "Repository open-source",
|
||
officialDocs: "Documenti ufficiali",
|
||
changelogTitle: "Registro modifiche",
|
||
changelogDescription: "Consulta le novità di ogni versione.",
|
||
changelogLoading: "Caricamento del registro modifiche...",
|
||
changelogLoadFailed: "Impossibile caricare il registro modifiche.",
|
||
changelogEmpty: "Nessuna voce nel registro modifiche.",
|
||
changelogPublishedOn: "Pubblicato il {date}",
|
||
changelogNew: "NEW",
|
||
changelogLoadMore: "Carica altro",
|
||
changelogOpenWebsite: "Apri sul sito",
|
||
changelogOpenGitHub: "GitHub Release",
|
||
changelogNoDetails: "Vedi GitHub Release per i dettagli.",
|
||
changelogRetry: "Riprova",
|
||
changelogSectionAdded: "Nuove funzionalità",
|
||
changelogSectionImproved: "Miglioramenti",
|
||
changelogSectionFixed: "Correzioni",
|
||
changelogSectionChanged: "Modifiche",
|
||
changelogSectionRemoved: "Rimossi",
|
||
shortcutUppercaseSelection: "Converti selezione in maiuscolo",
|
||
shortcutLowercaseSelection: "Converti selezione in minuscolo",
|
||
shortcutExPasteSqlInCondition: "ExPaste: incolla come condizione IN",
|
||
dateTimeSection: "Data e Ora",
|
||
globalDateTimeDisplayFormat: "Formato di visualizzazione globale",
|
||
globalDateTimeDisplayFormatDescription: "Applicato a tutti i campi data/ora nei database che non hanno una configurazione di formato colonna individuale.",
|
||
globalDateTimeExportFormat: "Formato di esportazione globale",
|
||
globalDateTimeExportFormatDescription: "Formatta uniformemente i campi data/ora durante l'esportazione in CSV, Excel, JSON, Markdown e testo.",
|
||
globalDateTimeImportFormat: "Formato di importazione globale",
|
||
globalDateTimeImportFormatDescription: "Analizza i campi data/ora nei file importati secondo questo formato; lascia vuoto per rilevare automaticamente i formati comuni.",
|
||
dateTimeFormatRaw: "Mantieni il valore originale del database",
|
||
dateTimeFormatAuto: "Riconoscimento automatico",
|
||
dateTimeFormatSearchPlaceholder: "Seleziona o inserisci il formato",
|
||
dateTimeFormatEmpty: "Inserisci un formato data/ora personalizzato",
|
||
},
|
||
driverStore: {
|
||
progressJreExtract: "Estrazione JRE...",
|
||
progressDownloadJre: "Download JRE in corso",
|
||
progressDownloadDriver: "Download driver in corso",
|
||
progressDownloadJdbcPlugin: "Download plugin JDBC in corso",
|
||
progressJdbcPluginExtract: "Installazione plugin JDBC...",
|
||
usageTitle: "Utilizzo dello spazio di archiviazione",
|
||
usageTotal: "Totale {size}",
|
||
usageTotalLabel: "Totale",
|
||
calculating: "Calcolo in corso...",
|
||
usageManagedJre: "JRE gestito",
|
||
usageAgentDrivers: "Agenti driver integrati",
|
||
usageDownloadCache: "Cache download",
|
||
usageJdbcPlugin: "Plugin JDBC",
|
||
usageJdbcDriverJars: "JAR dei driver JDBC",
|
||
clearDownloadCache: "Pulisci cache",
|
||
downloadCacheClearSuccess: "Cache download pulita",
|
||
downloadCacheClearFailed: "Pulizia cache download non riuscita: {error}",
|
||
offlineDownloadHint: "Per ambienti air-gapped, scarica i pacchetti driver offline su una macchina connessa a Internet, quindi importali qui.",
|
||
offlineDownloadLink: "Download driver offline",
|
||
searchDrivers: "Cerca nome driver, tipo, versione...",
|
||
searchJdbcDrivers: "Cerca nome o percorso driver JDBC...",
|
||
jdbcMavenCoordinatePlaceholder: "Coordinata Maven, es. org.postgresql:postgresql:42.7.7",
|
||
jdbcMavenInstall: "Installa da Maven",
|
||
jdbcMavenInstallSuccess: "Driver JDBC Maven installato",
|
||
jdbcSourceMaven: "Maven",
|
||
jdbcSourceManual: "Manuale",
|
||
noMatchingDrivers: "Nessun driver corrispondente.",
|
||
javaRuntimeSaved: "Impostazioni Java Runtime salvate",
|
||
javaRuntimeSaveFailed: "Impossibile salvare le impostazioni del runtime Java: {error}",
|
||
chooseJavaExecutable: "Scegli l'eseguibile Java",
|
||
driverInstallSuccess: "Driver {label} installato",
|
||
driverInstallFailed: "Installazione del driver {label} non riuscita: {error}",
|
||
driverUpdateBlocked: "Chiudi queste connessioni al database prima di aggiornare i driver: {labels}",
|
||
upgradeAllSuccess: "{count} driver aggiornato/i",
|
||
upgradeAllPartial: "{count} driver aggiornato/i. Saltati: {failed}",
|
||
upgradeAllFailed: "Aggiornamento in blocco non riuscito: {error}",
|
||
driverUninstallSuccess: "Driver {label} disinstallato",
|
||
driverUninstallFailed: "Disinstillazione del driver {label} non riuscita: {error}",
|
||
chooseOfflineDriverPackage: "Scegli pacchetto driver offline",
|
||
offlineImportSuccess: "Importazione offline completata. Installato/i {count} driver.",
|
||
offlineImportFailed: "Importazione offline non riuscita: {error}",
|
||
driverImportSuccess: "Driver {label} importato",
|
||
driverImportFailed: "Importazione del driver {label} non riuscita: {error}",
|
||
chooseDriverJar: "Scegli il file JAR del driver",
|
||
jreReinstallSuccess: "JRE {jre} reinstallato",
|
||
jreReinstallFailed: "Reinstallazione del JRE {jre} non riuscita: {error}",
|
||
jreUninstallSuccess: "JRE {jre} disinstallato",
|
||
chooseJdbcPluginZip: "Scegli il file zip del plugin JDBC",
|
||
agentDrivers: "Driver integrati",
|
||
jdbcDrivers: "Driver JDBC",
|
||
importing: "Importazione in corso...",
|
||
importOfflinePackage: "Importa pacchetto offline",
|
||
refresh: "Aggiorna",
|
||
javaRuntime: "Java Runtime",
|
||
javaRuntimeManaged: "JRE gestito da DBX",
|
||
javaRuntimeSystem: "Java di sistema",
|
||
javaRuntimeCustom: "Percorso personalizzato",
|
||
saving: "Salvataggio...",
|
||
customJavaPathPlaceholder: "/percorso/per/java o /percorso/per/jdk",
|
||
choose: "Scegli",
|
||
systemJavaHint: "Usa java dal PATH corrente.",
|
||
jreRuntimeTitle: "Runtime JRE {jre}",
|
||
notInstalled: "Non installato",
|
||
reinstalling: "Reinstallazione in corso",
|
||
installing: "Installazione in corso",
|
||
install: "Installa",
|
||
reinstall: "Reinstalla",
|
||
uninstall: "Disinstalla",
|
||
jreRuntime: "Runtime JRE",
|
||
jreRuntimeAutoDownloadHint: "Scaricato automaticamente durante l'installazione di un driver per la prima volta",
|
||
driversUpdatable: "{count} driver può essere aggiornato | {count} driver possono essere aggiornati",
|
||
updatesAvailableTitle: "Aggiornamenti disponibili",
|
||
updatesAvailableDescription: "Sono disponibili nuove versioni per i driver seguenti. Aggiorna per ottenere le ultime funzionalità e correzioni.",
|
||
allDriversTitle: "Tutti i driver",
|
||
upgradingProgress: "Aggiornamento in corso ({current}/{total})",
|
||
upgradeAll: "Aggiorna tutti",
|
||
queued: "In coda",
|
||
importLocalJar: "Importa JAR locale",
|
||
updating: "Aggiornamento in corso",
|
||
update: "Aggiorna",
|
||
localInstall: "Installazione locale",
|
||
runtimeDrivers: "Runtime",
|
||
storageTab: "Archiviazione",
|
||
runtimeTitle: "Runtime del driver",
|
||
runtimeHint: "Le metriche di runtime vengono raccolte solo mentre questo pannello è aperto.",
|
||
runtimeRunning: "In esecuzione",
|
||
runtimeMemory: "Memoria",
|
||
runtimeHealth: "Stato",
|
||
runtimeHealth_healthy: "Sano",
|
||
runtimeHealth_warning: "Avviso",
|
||
runtimeHealth_error: "Errore",
|
||
runtimeLastError: "Ultimo errore",
|
||
runtimeEmpty: "Nessun runtime di driver ancora avviato. Apri una connessione guidata da agenti per avviarne uno.",
|
||
runtimeKindAgent: "Agente",
|
||
runtimeKindPlugin: "Plugin",
|
||
runtimeSourceDaemon: "Demone",
|
||
runtimeSourceConnection: "Connessione",
|
||
runtimeStatus_running: "In esecuzione",
|
||
runtimeStatus_stopped: "Arrestato",
|
||
runtimeStatus_error: "Errore",
|
||
runtimeStatus_unknown: "Sconosciuto",
|
||
runtimePid: "PID",
|
||
runtimeUptime: "Tempo di attività",
|
||
runtimeActions: "Azioni",
|
||
runtimeStop: "Arresta",
|
||
runtimeRestart: "Riavvia",
|
||
runtimeControlConnectionOwned: "Chiudi la connessione al database per arrestare questo runtime.",
|
||
runtimeStopSuccess: "Runtime {label} arrestato",
|
||
runtimeStopFailed: "Arresto di {label} non riuscito: {error}",
|
||
runtimeRestartSuccess: "Runtime {label} riavviato",
|
||
runtimeRestartFailed: "Riavvio di {label} non riuscito: {error}",
|
||
driverStoreDir: "Percorso archiviazione driver",
|
||
driverStoreDirDescription: "Configura percorsi separati per il plugin JDBC e i dati Agent/JRE. L'app si riavvierà automaticamente dopo la migrazione.",
|
||
pluginStoreDir: "Directory plugin JDBC",
|
||
pluginStoreDirDescription: "Archivia il plugin JDBC, Maven resolver e i jar dei driver JDBC.",
|
||
agentStoreDir: "Directory Agent / JRE",
|
||
agentStoreDirDescription: "Archivia pacchetti driver Agent, JRE gestiti e cache runtime.",
|
||
driverStoreDirDefault: "Predefinito (directory di installazione)",
|
||
driverStoreDirChange: "Cambia",
|
||
driverStoreDirReset: "Ripristina",
|
||
driverStoreDirMigrating: "Migrazione {target} in corso…",
|
||
driverStoreDirConfirm: "La modifica di {target} migrerà i dati correlati nella nuova posizione. Le connessioni correlate potrebbero essere disconnesse durante la migrazione. L'app si riavvierà automaticamente dopo. Continuare?",
|
||
driverStoreDirMigrationFailed: "Migrazione driver fallita: {error}",
|
||
driverStoreDirDialogTitle: "Seleziona {target}",
|
||
driverStoreDirSuccess: "{target} cambiato, riavvio in corso…",
|
||
},
|
||
databaseExport: {
|
||
title: "Esporta Database",
|
||
options: "Opzioni",
|
||
includeStructure: "Struttura tabella (DDL)",
|
||
dropTableIfExists: "Aggiungi DROP TABLE IF EXISTS prima del DDL",
|
||
includeData: "Dati tabella (INSERT)",
|
||
includeObjects: "Viste / Procedure / Funzioni / Sequenze",
|
||
databaseSelection: "Database",
|
||
selectedDatabases: "{selected}/{total} selezionati",
|
||
selectAllDatabases: "Seleziona tutti",
|
||
filterDatabases: "Cerca database...",
|
||
clearDatabases: "Cancella",
|
||
tableSelection: "Tabelle",
|
||
selectedTables: "{selected}/{total} selezionate",
|
||
selectAllTables: "Seleziona tutte",
|
||
filterTables: "Cerca tabelle...",
|
||
clearTables: "Cancella",
|
||
loadingTables: "Caricamento tabelle...",
|
||
tableLoadError: "Caricamento tabelle non riuscito: {error}",
|
||
noTables: "Nessuna tabella trovata",
|
||
export: "Esporta",
|
||
exportAllDatabases: "Esporta tutti i database",
|
||
exporting: "Esportazione in corso...",
|
||
selectExportDirectory: "Seleziona directory di esportazione",
|
||
currentDatabase: "Database {current}/{total}",
|
||
currentTable: "Corrente: {table} ({current}/{total})",
|
||
rowsExported: "{count} righe esportate",
|
||
exportSuccess: "Database esportato con successo",
|
||
exportAllSuccess: "{count} database esportati con successo",
|
||
allDatabasesTask: "Tutti i database ({count})",
|
||
exportError: "Esportazione non riuscita: {error}",
|
||
exportCancelled: "Esportazione annullata",
|
||
runInBackground: "Esegui in background",
|
||
},
|
||
nacos: {
|
||
configs: "Configurazioni",
|
||
services: "Servizi",
|
||
raw: "Raw",
|
||
namespace: "Namespace",
|
||
createNamespace: "Crea Namespace",
|
||
editNamespace: "Modifica Namespace",
|
||
creatingNamespace: "Creazione...",
|
||
updatingNamespace: "Aggiornamento...",
|
||
namespaceCreated: 'Namespace "{name}" creato',
|
||
namespaceUpdated: 'Namespace "{name}" aggiornato',
|
||
namespaceId: "ID Namespace",
|
||
namespaceIdPlaceholder: "Lascia vuoto per generazione automatica Nacos",
|
||
namespaceName: "Nome Namespace",
|
||
namespaceNamePlaceholder: "Inserisci un nome namespace",
|
||
namespaceDesc: "Descrizione",
|
||
namespaceDescPlaceholder: "Predefinito al nome namespace",
|
||
dataId: "Data ID",
|
||
group: "Gruppo",
|
||
format: "Formato",
|
||
content: "Contenuto",
|
||
tags: "Tag",
|
||
application: "Applicazione",
|
||
description: "Descrizione",
|
||
advanced: "Avanzate",
|
||
collapse: "Comprimi",
|
||
load: "Carica",
|
||
save: "Salva",
|
||
saveAs: "Salva come",
|
||
saving: "Salvataggio...",
|
||
saved: "Configurazione salvata",
|
||
createdAndLoaded: "{dataId} creato e caricato",
|
||
savedAndLoaded: "{dataId} salvato e aggiornato",
|
||
deleted: "Configurazione eliminata",
|
||
delete: "Elimina",
|
||
copy: "Copia",
|
||
copied: "Copiato",
|
||
copyVerifyFailed: "Verifica degli appunti non riuscita dopo la scrittura",
|
||
export: "Esporta",
|
||
exported: "Esportato",
|
||
exportedTo: "Esportato in {path}",
|
||
exportFailed: "Esportazione non riuscita: {message}",
|
||
history: "History",
|
||
configHistory: "Config history",
|
||
historyDetail: "History detail",
|
||
historyCompareTitle: "History Version Compare",
|
||
currentPublishedContent: "Current published content:",
|
||
historyVersionContent: "History version content:",
|
||
updatedAt: "Updated at",
|
||
operationType: "Operation",
|
||
operator: "Operator",
|
||
view: "View",
|
||
compare: "Compare",
|
||
rollback: "Rollback",
|
||
loadingHistory: "Loading history...",
|
||
noHistory: "No history versions",
|
||
noHistoryHint: "Refresh if this config was just published. Some Nacos versions may not expose history APIs.",
|
||
historyCreate: "Create",
|
||
historyUpdate: "Update",
|
||
historyDelete: "Delete",
|
||
historyRollback: "Rollback",
|
||
confirmRollbackTitle: "Rollback Nacos config",
|
||
confirmRollbackMessage: "This will roll the current config back to the selected history version.",
|
||
rollbackSuccess: "Config rolled back",
|
||
publish: "Pubblica",
|
||
dataIdRequired: "Data ID è obbligatorio",
|
||
allGroups: "Tutti i gruppi",
|
||
noConfigs: "Nessuna configurazione",
|
||
selectConfig: "Seleziona o crea una configurazione",
|
||
noServices: "Nessun servizio",
|
||
selectService: "Seleziona un servizio",
|
||
service: "Servizio",
|
||
instances: "Istanze",
|
||
instanceCount: "{count} istanze",
|
||
refresh: "Aggiorna",
|
||
address: "Indirizzo",
|
||
cluster: "Cluster",
|
||
weight: "Peso",
|
||
state: "Stato",
|
||
actions: "Azioni",
|
||
query: "Query",
|
||
body: "Corpo",
|
||
response: "Risposta",
|
||
template: "Template",
|
||
configDiffTitle: "Confronto contenuto configurazione",
|
||
inlineCompare: "Confronto inline",
|
||
currentVersionContent: "Versione ufficiale attuale:",
|
||
publishVersionContent: "Contenuto di questa pubblicazione:",
|
||
confirmSaveTitle: "Rivedi modifiche configurazione Nacos",
|
||
confirmSaveMessage: "Salvare questa modifica? +{added} / -{removed} righe.",
|
||
confirmDeleteTitle: "Elimina configurazione Nacos",
|
||
confirmDeleteMessage: "Questo rimuove la configurazione selezionata da Nacos.",
|
||
confirmInstanceTitle: "Aggiorna istanza Nacos",
|
||
confirmInstanceMessage: "Conferma lo stato di destinazione dell'istanza.",
|
||
confirmRawTitle: "Invia richiesta Raw API modificante",
|
||
confirmRawMessage: "Questa richiesta Raw API può modificare lo stato di Nacos.",
|
||
rawTemplate: {
|
||
serverState: "Stato server",
|
||
namespaceList: "Lista namespace",
|
||
configDetail: "Dettaglio configurazione",
|
||
serviceList: "Lista servizi",
|
||
instanceList: "Lista istanze",
|
||
},
|
||
healthy: "Sana",
|
||
unhealthy: "Non sana",
|
||
enabled: "Abilitata",
|
||
offline: "Offline",
|
||
ephemeral: "Effimera",
|
||
persistent: "Persistente",
|
||
enable: "Abilita",
|
||
disable: "Disabilita",
|
||
markHealthy: "Segna sana",
|
||
markUnhealthy: "Segna non sana",
|
||
send: "Invia",
|
||
total: "{count} totali",
|
||
prev: "Prec.",
|
||
next: "Succ.",
|
||
test: "Test",
|
||
readOnly: "Sola lettura",
|
||
},
|
||
gridfsBrowser: {
|
||
bucketCount: "Bucket",
|
||
fileCount: "File",
|
||
name: "Nome",
|
||
totalSize: "Dimensione",
|
||
chunkSize: "Dimensione chunk",
|
||
uploadDate: "Data di caricamento",
|
||
contentType: "Tipo di contenuto",
|
||
metadata: "Metadati",
|
||
selectBucket: "Seleziona un bucket GridFS per visualizzarlo o aprirlo.",
|
||
selectFile: "Seleziona un file GridFS per visualizzarlo o gestirlo.",
|
||
emptyBuckets: "Nessun bucket GridFS presente. Puoi crearne uno nuovo.",
|
||
emptyFiles: "Il bucket attuale non contiene file. Puoi caricarne uno.",
|
||
createBucket: "Crea bucket",
|
||
openBucket: "Apri bucket",
|
||
deleteBucket: "Elimina bucket",
|
||
createTitle: "Crea bucket GridFS",
|
||
deleteTitle: "Elimina bucket GridFS",
|
||
deleteMessage: "Sei sicuro di voler eliminare il bucket GridFS selezionato e tutti i file in esso contenuti?",
|
||
bucketName: "Nome bucket",
|
||
bucketNamePlaceholder: "example_bucket",
|
||
bucketCreated: "Bucket {bucket} creato.",
|
||
bucketDeleted: "Bucket {bucket} eliminato.",
|
||
uploadFile: "Carica file",
|
||
downloadFile: "Scarica file",
|
||
downloadSelected: "Scarica selezionati",
|
||
deleteFile: "Elimina file",
|
||
selectedCount: "{count} selezionati",
|
||
deleteFileTitle: "Elimina file GridFS",
|
||
deleteFileMessage: "Sei sicuro di voler eliminare il file selezionato dal bucket GridFS corrente?",
|
||
fileUploaded: "{fileName} caricato.",
|
||
fileDeleted: "{fileName} eliminato.",
|
||
},
|
||
extension: {
|
||
installTitle: "Installa estensione",
|
||
manageTitle: "Gestisci estensioni",
|
||
name: "Nome estensione",
|
||
namePlaceholder: "Es: pg_stat_statements",
|
||
install: "Installa",
|
||
drop: "Elimina",
|
||
available: "Estensioni disponibili",
|
||
installed: "Installate",
|
||
noAvailable: "Tutte le estensioni disponibili sono installate.",
|
||
noInstalled: "Nessuna estensione installata.",
|
||
},
|
||
sqlFileTree: {
|
||
title: "File SQL",
|
||
openFolder: "Apri cartella",
|
||
closePanel: "Chiudi",
|
||
loading: "Caricamento in corso...",
|
||
noFolder: "Nessuna cartella aperta",
|
||
noSqlFiles: "Nessun file SQL trovato",
|
||
folderAlreadyOpen: "Questa cartella è già aperta",
|
||
removeFolder: "Rimuovi cartella",
|
||
openFailed: "Apertura cartella fallita: {message}",
|
||
loadFailed: "Caricamento file SQL fallito: {message}",
|
||
desktopOnly: "Questa funzionalità è disponibile solo su desktop",
|
||
refreshFolder: "Aggiorna cartella",
|
||
refreshAll: "Aggiorna tutto",
|
||
refreshed: "Aggiornato",
|
||
revealInFileManager: "Mostra nel file manager",
|
||
revealFailed: "Apertura del file manager non riuscita: {message}",
|
||
copyPath: "Copia percorso",
|
||
pathCopied: "Percorso copiato",
|
||
copyFailed: "Copia del percorso non riuscita",
|
||
openFile: "Apri",
|
||
executeSqlFile: "Esegui file SQL",
|
||
expandAll: "Espandi tutto",
|
||
collapseAll: "Comprimi tutto",
|
||
},
|
||
mqTopics: {
|
||
title: "Gestione topic",
|
||
searchPlaceholder: "Cerca topic",
|
||
includeNonPersistent: "Includi topic non persistenti",
|
||
refresh: "Aggiorna",
|
||
refreshing: "Aggiornamento in corso...",
|
||
createTopic: "Crea topic",
|
||
selectTenantNamespace: "Seleziona prima tenant e namespace",
|
||
loading: "Caricamento in corso...",
|
||
noTopics: "Nessun topic in questo namespace",
|
||
noMatches: "Nessun topic corrispondente",
|
||
name: "Nome",
|
||
type: "Tipo",
|
||
partitions: "Partizioni",
|
||
actions: "Azioni",
|
||
nonPersistent: "Non persistente",
|
||
partitionedTopic: "Topic partizionato",
|
||
normalTopic: "Topic normale",
|
||
partitionCount: "{count} partizioni",
|
||
partitionsUnknown: "Numero di partizioni sconosciuto",
|
||
adjustPartitions: "Regola partizioni",
|
||
delete: "Elimina",
|
||
tenantNamespace: "Tenant / Namespace",
|
||
topicName: "Nome topic",
|
||
topicNamePlaceholder: "es. my-topic",
|
||
persistentRecommended: "Topic persistente (consigliato)",
|
||
persistentHint: "I topic persistenti salvano i messaggi su disco, quelli non persistenti solo in memoria.",
|
||
enablePartitions: "Abilita partizioni",
|
||
partitionQuantity: "Numero di partizioni",
|
||
partitionHint: "Le partizioni migliorano le prestazioni di concorrenza ma aumentano il consumo di risorse.",
|
||
cancel: "Annulla",
|
||
create: "Crea",
|
||
updatePartitionsTitle: "Regola numero partizioni: {name}",
|
||
currentPartitions: "Partizioni attuali",
|
||
newPartitions: "Nuove partizioni",
|
||
partitionMinHint: "Il numero di partizioni può solo aumentare, non diminuire. Minimo: {min}",
|
||
update: "Aggiorna",
|
||
readOnly: "La connessione corrente è in modalità sola lettura, impossibile eseguire operazioni di scrittura.",
|
||
topicNameRequired: "Il nome del topic non può essere vuoto",
|
||
currentPartitionsUnknown: "Numero di partizioni attuali sconosciuto, impossibile regolare le partizioni in modo sicuro.",
|
||
partitionMustIncrease: "Il nuovo numero di partizioni deve essere maggiore di quello attuale.",
|
||
confirmDelete: 'Confermi di eliminare il topic "{name}"? Questa operazione è irreversibile.',
|
||
},
|
||
mqAdmin: {
|
||
viewTenant: "Visualizza tenant",
|
||
viewNamespace: "Visualizza namespace",
|
||
viewTopic: "Visualizza topic",
|
||
readOnly: "Sola lettura",
|
||
tabTenants: "Tenant",
|
||
tabNamespaces: "Namespace",
|
||
tabTopics: "Topic",
|
||
tabSubscriptions: "Sottoscrizioni",
|
||
tabMonitoring: "Monitoraggio",
|
||
tabClients: "Clienti",
|
||
tabMessages: "Messaggi",
|
||
tabBroker: "Broker",
|
||
tabPolicies: "Politiche",
|
||
tabPermissions: "Permessi",
|
||
tabRawApi: "Raw API",
|
||
},
|
||
mqMessages: {
|
||
title: "Invia messaggio",
|
||
clear: "Pulisci",
|
||
selectNamespaceOrTopicFirst: "Seleziona prima un namespace o un topic",
|
||
readOnlyCannotSend: "Questa connessione è in sola lettura e non può inviare messaggi",
|
||
selectTargetTopic: "Seleziona un topic di destinazione",
|
||
messageContentRequired: "Il contenuto del messaggio è obbligatorio",
|
||
sendSuccess: "Messaggio inviato — partizione: {partition}, offset: {offset}",
|
||
targetTopic: "Topic di destinazione",
|
||
topicLoading: "Caricamento in corso...",
|
||
topicSearchPlaceholder: "Digita o cerca topic...",
|
||
refreshTopicList: "Aggiorna elenco topic",
|
||
topicOptionWithPartitions: "{label} ({partitions} partizioni)",
|
||
noTopicsAvailable: "Nessun topic disponibile",
|
||
topicSearchHint: "Cerca per parola chiave o incolla il nome di un topic.",
|
||
messageKey: "Chiave del messaggio",
|
||
optional: "Opzionale",
|
||
messageContent: "Contenuto del messaggio",
|
||
formatJson: "Formatta JSON",
|
||
messageHeaders: "Intestazioni",
|
||
headersPlaceholder: "chiave: valore (una per riga)",
|
||
sending: "Invio in corso...",
|
||
sendMessage: "Invia messaggio",
|
||
messageList: "Messaggi",
|
||
loadMessages: "Carica messaggi",
|
||
loading: "Caricamento in corso...",
|
||
peekDefaultHint: "Senza partizione, legge tutte le partizioni dall'inizio (earliest), fino a {count} messaggi.",
|
||
count: "Quantità",
|
||
advancedFilter: "Avanzate (partizione / offset)",
|
||
partition: "Partizione",
|
||
partitionPlaceholderAll: "Vuoto = tutte",
|
||
offset: "Offset",
|
||
offsetPlaceholderEarliest: "Vuoto = inizio (earliest)",
|
||
messagesLoading: "Caricamento messaggi...",
|
||
noMessages: "Nessun messaggio",
|
||
selectTopicBeforeLoad: "Seleziona un topic prima di caricare i messaggi",
|
||
partitionMustBeNonNegativeInt: "La partizione deve essere un intero ≥ 0; lascia vuoto per tutte le partizioni",
|
||
offsetMustBeNonNegativeInt: "L'offset deve essere un intero ≥ 0; lascia vuoto per l'inizio (earliest)",
|
||
metaPartition: "partizione {partition}",
|
||
metaOffset: "offset {offset}",
|
||
metaKey: "chiave {key}",
|
||
jsonBodyPlaceholder: "{'{'}\"key\": \"value\"{'}'}",
|
||
},
|
||
mqMonitoring: {
|
||
title: "Monitoraggio",
|
||
autoRefresh: "Aggiornamento automatico",
|
||
refreshInterval5s: "5s",
|
||
refreshInterval10s: "10s",
|
||
refreshInterval30s: "30s",
|
||
refreshInterval60s: "60s",
|
||
refreshing: "Aggiornamento in corso...",
|
||
refreshNow: "Aggiorna",
|
||
selectTopicFirst: "Seleziona prima un topic",
|
||
loadingStats: "Caricamento dati di monitoraggio...",
|
||
kafkaTopicOverview: "Panoramica topic Kafka",
|
||
partitionCount: "Partizioni",
|
||
replicationFactor: "Fattore di replica",
|
||
messageCount: "Messaggi",
|
||
logEndOffset: "Log end offset",
|
||
offsetAndReplicaStatus: "Offset e repliche",
|
||
beginOffset: "Offset iniziale",
|
||
leaderCount: "Leader",
|
||
isrHealthyPartitions: "ISR integre",
|
||
noLeaderPartitions: "Senza leader",
|
||
kafkaPartitionDetails: "Partizioni Kafka",
|
||
noKafkaPartitionMetrics: "Nessuna metrica di partizione nella risposta Kafka",
|
||
tablePartition: "Partizione",
|
||
tableBeginOffset: "Offset iniziale",
|
||
tableLogEndOffset: "Log end offset",
|
||
tableMessageCount: "Messaggi",
|
||
tableLeader: "Leader",
|
||
tableReplicas: "Replica",
|
||
tableIsr: "ISR",
|
||
tableStatus: "Stato",
|
||
statusNoLeader: "Senza leader",
|
||
statusIsrIncomplete: "ISR incompleto",
|
||
statusHealthy: "Integro",
|
||
kafkaMessageQuery: "Interrogazione messaggi Kafka",
|
||
querying: "Interrogazione in corso...",
|
||
queryMessages: "Interroga",
|
||
queryHint: "Ometti PARTITION / OFFSET per leggere tutte le partizioni (max 100). Aggiungili per restringere l'intervallo.",
|
||
sqlSyntaxError: 'È supportato solo SELECT * FROM "topic" [PARTITION n] [OFFSET n] [LIMIT n]',
|
||
messagesLoading: "Caricamento messaggi...",
|
||
noMessages: "Nessun messaggio",
|
||
messageRate: "Velocità messaggi",
|
||
inboundRate: "Velocità in ingresso",
|
||
outboundRate: "Velocità in uscita",
|
||
inboundThroughput: "Throughput in ingresso",
|
||
outboundThroughput: "Throughput in uscita",
|
||
rateTrend: "Andamento velocità",
|
||
backlogTrend: "Andamento backlog",
|
||
consumerLag: "Ritardo consumer",
|
||
storageAndBacklog: "Storage e backlog",
|
||
storageSize: "Dimensione storage",
|
||
backlogSize: "Dimensione backlog",
|
||
backlogMessageCount: "Messaggi in backlog",
|
||
messageCounters: "Contatori messaggi",
|
||
publishedMessages: "Pubblicati",
|
||
consumedMessages: "Consumati",
|
||
connectionStats: "Connessioni",
|
||
subscriptionCount: "Sottoscrizioni",
|
||
producerCount: "Produttori",
|
||
partitionDetails: "Partizioni",
|
||
tableInbound: "In",
|
||
tableOutbound: "Out",
|
||
tableInboundThroughput: "Throughput in",
|
||
tableOutboundThroughput: "Throughput out",
|
||
tableBacklogMessages: "Msg backlog",
|
||
tableBacklogSize: "Dimensione backlog",
|
||
tableProducers: "Produttori",
|
||
tableSubscriptions: "Sottoscrizioni",
|
||
producers: "Produttori",
|
||
subscriptions: "Sottoscrizioni",
|
||
tableName: "Nome",
|
||
tableRate: "Velocità",
|
||
tableAddress: "Indirizzo",
|
||
tableType: "Tipo",
|
||
tableBacklog: "Backlog",
|
||
tableConsumers: "Consumatori",
|
||
noProducers: "Nessun produttore",
|
||
noSubscriptions: "Nessuna sottoscrizione",
|
||
noPartitionMetricsFromBroker: "Nessuna metrica di partizione dal broker",
|
||
nonPartitionedTopicNoDetails: "I topic non partizionati non hanno dettagli sulle partizioni",
|
||
healthIndicators: "Integrità",
|
||
messageFlow: "Flusso messaggi",
|
||
backlogStatus: "Backlog",
|
||
producersLabel: "Produttori",
|
||
subscriptionsLabel: "Sottoscrizioni",
|
||
flowActive: "Attivo",
|
||
flowIdle: "Inattivo",
|
||
backlogNormal: "Normale",
|
||
backlogHigh: "Elevato",
|
||
producerConnected: "Connesso",
|
||
producerDisconnected: "Nessuno",
|
||
subscriptionActive: "Attiva",
|
||
subscriptionNone: "Nessuna",
|
||
chartLegendIn: "In",
|
||
chartLegendOut: "Out",
|
||
chartLegendMessages: "Messaggi",
|
||
chartLegendBytes: "Byte",
|
||
chartLegendConsumerLag: "Ritardo consumer",
|
||
chartAxisMsgPerSec: "msg/s",
|
||
chartAxisMsg: "msg",
|
||
chartAxisBytes: "byte",
|
||
chartAxisMs: "ms",
|
||
metaPartition: "partizione {partition}",
|
||
metaOffset: "offset {offset}",
|
||
metaKey: "chiave {key}",
|
||
},
|
||
mqTenants: {
|
||
title: "Gestione tenant",
|
||
createTenant: "Crea tenant",
|
||
notSupported: "La gestione tenant non è supportata per questo sistema di messaggistica",
|
||
readOnly: "La connessione corrente è in modalità sola lettura, impossibile eseguire operazioni di scrittura.",
|
||
loading: "Caricamento in corso...",
|
||
name: "Nome",
|
||
adminRoles: "Ruoli amministratore",
|
||
allowedClusters: "Cluster consentiti*",
|
||
actions: "Azioni",
|
||
none: "Nessuno",
|
||
edit: "Modifica",
|
||
delete: "Elimina",
|
||
createDialogTitle: "Crea tenant",
|
||
editDialogTitle: "Modifica tenant: {name}",
|
||
tenantName: "Nome tenant*",
|
||
tenantNamePlaceholder: "es. my-tenant",
|
||
addRolePlaceholder: "Aggiungi ruolo",
|
||
add: "Aggiungi",
|
||
selectClustersPlaceholder: "Seleziona cluster consentiti",
|
||
noClustersDetectedPlaceholder: "Nessun cluster rilevato; aggiungi manualmente",
|
||
clustersNotReturned: "La connessione non ha restituito un elenco di cluster",
|
||
addClusterPlaceholder: "Aggiungi cluster manualmente",
|
||
clustersRequiredHint: "Seleziona o aggiungi almeno un cluster consentito",
|
||
cancel: "Annulla",
|
||
create: "Crea",
|
||
save: "Salva",
|
||
confirmDelete: 'Confermi di eliminare il tenant "{name}"? Questa operazione è irreversibile.',
|
||
tenantNameRequired: "Il nome del tenant è obbligatorio",
|
||
allowedClustersRequired: "I cluster consentiti sono obbligatori",
|
||
},
|
||
mqNamespaces: {
|
||
title: "Gestione namespace",
|
||
createNamespace: "Crea namespace",
|
||
notSupported: "La gestione namespace non è supportata per questo sistema di messaggistica",
|
||
selectTenantFirst: "Seleziona prima un tenant",
|
||
readOnly: "La connessione corrente è in modalità sola lettura, impossibile eseguire operazioni di scrittura.",
|
||
loading: "Caricamento in corso...",
|
||
name: "Nome",
|
||
tenant: "Tenant",
|
||
adminRoles: "Ruoli amministratore",
|
||
actions: "Azioni",
|
||
none: "Nessuno",
|
||
editRoles: "Modifica ruoli",
|
||
delete: "Elimina",
|
||
createDialogTitle: "Crea namespace",
|
||
namespaceName: "Nome namespace*",
|
||
namespaceNamePlaceholder: "es. my-namespace",
|
||
cancel: "Annulla",
|
||
create: "Crea",
|
||
confirmDelete: 'Confermi di eliminare il namespace "{name}"? Questa operazione è irreversibile.',
|
||
namespaceNameRequired: "Il nome del namespace è obbligatorio",
|
||
},
|
||
mqSubscriptions: {
|
||
title: "Gestione sottoscrizioni",
|
||
createSubscription: "Crea sottoscrizione",
|
||
selectTopicFirst: "Seleziona prima un topic",
|
||
readOnly: "La connessione corrente è in modalità sola lettura, impossibile eseguire operazioni di scrittura.",
|
||
loading: "Caricamento in corso...",
|
||
noSubscriptions: "Nessuna sottoscrizione per questo topic",
|
||
subscriptionName: "Nome sottoscrizione",
|
||
type: "Tipo",
|
||
backlog: "Backlog",
|
||
consumeRate: "Velocità di consumo",
|
||
consumers: "Consumatori",
|
||
actions: "Azioni",
|
||
consumerCount: "{count} consumatori",
|
||
msgRate: "{rate} msg/s",
|
||
resetCursor: "Reimposta cursore",
|
||
skipMessages: "Salta messaggi",
|
||
clearBacklog: "Svuota backlog",
|
||
peek: "Peek",
|
||
expireMessages: "Fai scadere messaggi",
|
||
delete: "Elimina",
|
||
createDialogTitle: "Crea sottoscrizione",
|
||
topic: "Topic",
|
||
subscriptionNameLabel: "Nome sottoscrizione*",
|
||
subscriptionNamePlaceholder: "es. my-subscription",
|
||
startPosition: "Posizione iniziale",
|
||
startFromEarliest: "Dal primo messaggio (Earliest)",
|
||
startFromLatest: "Dall'ultimo messaggio (Latest)",
|
||
resetDialogTitle: "Reimposta cursore: {name}",
|
||
resetTo: "Reimposta a",
|
||
earliest: "Primo messaggio (Earliest)",
|
||
latest: "Ultimo messaggio (Latest)",
|
||
timestamp: "Timestamp specifico",
|
||
timestampMs: "Timestamp (ms)",
|
||
currentTime: "Ora corrente: {time}",
|
||
reset: "Reimposta",
|
||
skipDialogTitle: "Salta messaggi: {name}",
|
||
skipMode: "Modalità salto",
|
||
skipCount: "Salta quantità specificata",
|
||
skipAll: "Salta tutto il backlog",
|
||
skipCountLabel: "Quantità da saltare",
|
||
skip: "Salta",
|
||
peekDialogTitle: "Peek messaggi: {name}",
|
||
count: "Quantità",
|
||
refresh: "Aggiorna",
|
||
noPeekMessages: "Nessun messaggio da visualizzare",
|
||
close: "Chiudi",
|
||
expireDialogTitle: "Fai scadere messaggi: {name}",
|
||
expireSeconds: "Tempo di scadenza (secondi)",
|
||
expireHint: "Eliminerà tutti i messaggi più vecchi di {seconds} secondi",
|
||
expire: "Fai scadere",
|
||
cancel: "Annulla",
|
||
create: "Crea",
|
||
confirmDelete: 'Confermi di eliminare la sottoscrizione "{name}"? Questa operazione è irreversibile.',
|
||
confirmClearBacklog: 'Svuotare tutti i messaggi in backlog per la sottoscrizione "{name}"?',
|
||
subscriptionNameRequired: "Il nome della sottoscrizione è obbligatorio",
|
||
peekMessageKey: "chiave={key}",
|
||
},
|
||
mqClients: {
|
||
title: "Produttori / Consumatori",
|
||
unloadTopic: "Scarica topic",
|
||
unloading: "Scaricamento in corso...",
|
||
refresh: "Aggiorna",
|
||
refreshing: "Aggiornamento in corso...",
|
||
selectTopicFirst: "Seleziona prima un topic",
|
||
confirmUnload: "Scaricare questo topic? I produttori e i consumatori attivi si riconnetteranno.",
|
||
aggregateTopic: "Topic aggregato",
|
||
kafkaPartitionStatus: "Stato partizioni Kafka",
|
||
partitionCount: "{count} partizioni",
|
||
partition: "Partizione",
|
||
beginOffset: "Offset iniziale",
|
||
latestOffset: "Offset più recente",
|
||
messageCount: "Messaggi",
|
||
leader: "Leader",
|
||
replicas: "Replica",
|
||
isr: "ISR",
|
||
partitionClients: "Clienti per partizione",
|
||
inboundRate: "Velocità in ingresso",
|
||
outboundRate: "Velocità in uscita",
|
||
producers: "Produttori",
|
||
subscriptions: "Sottoscrizioni",
|
||
consumers: "Consumatori",
|
||
activeProducers: "Produttori attivi",
|
||
noActiveProducers: "Nessun produttore attivo",
|
||
name: "Nome",
|
||
id: "ID",
|
||
address: "Indirizzo",
|
||
version: "Versione",
|
||
rate: "Velocità",
|
||
throughput: "Throughput",
|
||
rateValue: "{value} msg/s",
|
||
activeConsumers: "Consumatori attivi",
|
||
noSubscriptions: "Questo topic non ha sottoscrizioni",
|
||
noConsumersOnPartition: "Nessun consumatore attivo su questa sottoscrizione di partizione",
|
||
noConsumersOnSubscription: "Nessun consumatore attivo su questa sottoscrizione",
|
||
permits: "Permessi",
|
||
},
|
||
mqPolicies: {
|
||
title: "Gestione politiche",
|
||
refresh: "Aggiorna",
|
||
refreshing: "Aggiornamento in corso...",
|
||
selectTopicFirst: "Seleziona prima un topic",
|
||
selectNamespaceOrTopic: "Seleziona un namespace o un topic",
|
||
readOnly: "La connessione corrente è in modalità sola lettura, impossibile eseguire operazioni di scrittura.",
|
||
readonlyHint: "Questa connessione è in sola lettura; la modifica delle politiche è disabilitata.",
|
||
publishRate: "Limite velocità di pubblicazione",
|
||
msgsPerSecond: "Messaggi / secondo",
|
||
bytesPerSecond: "Byte / secondo",
|
||
save: "Salva",
|
||
dispatchRate: "Limite velocità di dispatch",
|
||
msgsPerPeriod: "Messaggi / periodo",
|
||
bytesPerPeriod: "Byte / periodo",
|
||
periodSeconds: "Periodo (secondi)",
|
||
subscribeRate: "Limite velocità di sottoscrizione",
|
||
msgsPerConsumerPerPeriod: "Messaggi per consumatore / periodo",
|
||
backlogQuota: "Quota backlog",
|
||
sizeLimitBytes: "Limite dimensione (byte)",
|
||
timeLimitSeconds: "Limite tempo (secondi)",
|
||
policy: "Politica",
|
||
type: "Tipo",
|
||
backlogPolicyProducerRequestHold: "Metti in attesa le richieste del produttore",
|
||
backlogPolicyProducerException: "Rifiuta con eccezione",
|
||
backlogPolicyConsumerBacklogEviction: "Elimina backlog del consumatore",
|
||
retention: "Retention messaggi",
|
||
retentionTimeMinutes: "Tempo di retention (minuti)",
|
||
retentionSizeMb: "Dimensione retention (MB)",
|
||
effectivePolicies: "Politiche effettive",
|
||
savedNotice: "{policy} salvata",
|
||
},
|
||
mqPermissions: {
|
||
title: "Permessi",
|
||
refresh: "Aggiorna",
|
||
refreshing: "Aggiornamento in corso...",
|
||
selectNamespaceOrTopic: "Seleziona prima un namespace o un topic",
|
||
readOnly: "La connessione corrente è in modalità sola lettura, impossibile eseguire operazioni di scrittura.",
|
||
readonlyHint: "Questa connessione è in sola lettura; concessione e revoca sono disabilitate.",
|
||
grantRole: "Concedi ruolo",
|
||
roleName: "Nome ruolo",
|
||
roleNamePlaceholder: "es. app-producer",
|
||
actions: "Azioni",
|
||
grant: "Concedi",
|
||
currentPermissions: "Permessi attuali",
|
||
role: "Ruolo",
|
||
operations: "Operazioni",
|
||
token: "Token",
|
||
revoke: "Revoca",
|
||
noPermissions: "Nessun record di permesso",
|
||
clientTokenTitle: "Token client: {role}",
|
||
missingSigningKeyTitle: "Chiave di firma token non configurata",
|
||
missingSigningKeyMessage: "Questa connessione MQ non ha una chiave di firma token Broker configurata, quindi non è possibile emettere token client.",
|
||
missingSigningKeyDetail: 'Modifica la connessione e imposta "Broker token signing" su HS256 SECRET o RS256 PRIVATE, quindi fornisci la chiave di firma prima di generare i token.',
|
||
tokenShowOnceWarning: "Il token viene mostrato una sola volta. Copialo e conservalo immediatamente.",
|
||
copyToken: "Copia token",
|
||
issueNewToken: "Emetti nuovo token",
|
||
neverExpires: "Non scade mai",
|
||
expiryDays: "Scadenza (giorni)",
|
||
note: "Nota",
|
||
notePlaceholder: "es. per rt-erp-server",
|
||
issuing: "Emissione in corso...",
|
||
generateToken: "Genera token",
|
||
tokenRevokeHint: "La revoca dei permessi del ruolo non invalida immediatamente i JWT emessi; attendi la scadenza o ruota la chiave di firma del broker.",
|
||
issueRecords: "Registri emissione",
|
||
time: "Ora",
|
||
algorithm: "Algoritmo",
|
||
expires: "Scadenza",
|
||
fingerprint: "Fingerprint",
|
||
noteColumn: "Nota",
|
||
unlimited: "Permanente",
|
||
loading: "Caricamento in corso...",
|
||
noIssueRecords: "Nessun registro di emissione",
|
||
close: "Chiudi",
|
||
kafkaAuthorizerNotConfigured: "Questo cluster Kafka non ha un authorizer configurato. Aggiungi authorizer.class.name nella configurazione del broker per il supporto ACL.",
|
||
kafkaAuthorizerDisabled: "Questo cluster Kafka non ha un authorizer abilitato. Abilita un authorizer nella configurazione del broker per concedere permessi.",
|
||
roleNameRequired: "Il nome del ruolo è obbligatorio",
|
||
selectAtLeastOneAction: "Seleziona almeno un'azione",
|
||
grantedRole: "Concesso {role}",
|
||
confirmRevoke: 'Revocare i permessi per il ruolo "{role}"?',
|
||
revokedRole: "Revocato {role}",
|
||
roleNameEmpty: "Il nome del ruolo non può essere vuoto",
|
||
expiryMustBePositive: "La scadenza deve essere maggiore di 0 giorni",
|
||
},
|
||
mqBroker: {
|
||
title: "Cluster Broker",
|
||
autoRefresh: "Aggiornamento automatico",
|
||
refreshInterval5s: "5s",
|
||
refreshInterval10s: "10s",
|
||
refreshInterval30s: "30s",
|
||
refreshInterval60s: "60s",
|
||
refreshing: "Aggiornamento in corso...",
|
||
refreshNow: "Aggiorna ora",
|
||
loading: "Caricamento in corso...",
|
||
clusterOverview: "Panoramica cluster",
|
||
clusterId: "ID cluster",
|
||
unknown: "Sconosciuto",
|
||
brokerCount: "Broker",
|
||
controller: "Controller",
|
||
controllerNode: "Nodo {id} · {host}",
|
||
brokerNodes: "Nodi broker",
|
||
nodeId: "ID nodo",
|
||
host: "Host",
|
||
port: "Porta",
|
||
rack: "Rack",
|
||
role: "Ruolo",
|
||
roleController: "Controller",
|
||
roleFollower: "Follower",
|
||
noBrokerNodes: "Nessuna informazione sui nodi broker",
|
||
},
|
||
mqRaw: {
|
||
title: "Raw API",
|
||
sending: "Invio in corso...",
|
||
sendRequest: "Invia richiesta",
|
||
readOnlyHint: "Questa connessione è in sola lettura; sono consentite solo richieste GET, HEAD e OPTIONS.",
|
||
commonEndpoints: "Endpoint comuni",
|
||
fillFromSelection: "Compila richiesta dalla selezione corrente",
|
||
expand: "Espandi",
|
||
collapse: "Comprimi",
|
||
method: "Metodo",
|
||
path: "Percorso",
|
||
pathPlaceholder: "/admin/v2/...",
|
||
queryParams: "Parametri query",
|
||
queryPlaceholder: "key=value, uno per riga",
|
||
jsonBody: "JSON Body",
|
||
format: "Formatta",
|
||
bodyPlaceholder: "es. {'{'}\"key\":\"value\"{'}'}",
|
||
response: "Risposta",
|
||
textResponse: "Risposta testuale",
|
||
noRequestYet: "Nessuna richiesta inviata ancora",
|
||
readOnly: "La connessione corrente è in modalità sola lettura, impossibile eseguire operazioni di scrittura.",
|
||
pathRequired: "Il percorso della richiesta è obbligatorio",
|
||
jsonBodyInvalid: "Corpo JSON non valido: {error}",
|
||
presetBrokerVersion: "Versione broker",
|
||
presetBrokerVersionDesc: "Stringa versione broker",
|
||
presetClusters: "Elenco cluster",
|
||
presetClustersDesc: "Elenca cluster Pulsar configurati",
|
||
presetTenant: "Dettagli tenant",
|
||
presetTenantDesc: "Visualizza adminRoles / allowedClusters",
|
||
presetNamespacePolicies: "Politiche namespace",
|
||
presetNamespacePoliciesDesc: "Struttura grezza delle politiche namespace",
|
||
presetBundles: "Elenco bundle",
|
||
presetBundlesDesc: "Distribuzione bundle namespace",
|
||
presetTopicInternalStats: "Statistiche interne topic",
|
||
presetTopicInternalStatsDesc: "Dettagli ledger / cursore / backlog",
|
||
presetPartitionedStats: "Metriche per partizione",
|
||
presetPartitionedStatsDesc: "Velocità, produttori e consumatori per partizione",
|
||
presetSchema: "Schema più recente",
|
||
presetSchemaDesc: "Definizione schema topic corrente",
|
||
},
|
||
production: {
|
||
title: "Ambiente di produzione",
|
||
connection: "Connessione di produzione",
|
||
enable: "Abilita protezione ambiente di produzione",
|
||
disabledDescription: "Dopo l'attivazione, è possibile scegliere di proteggere tutti i database o database specifici.",
|
||
scope: "Ambito di protezione",
|
||
allDatabases: "Tutti i database",
|
||
selectedDatabases: "Database selezionati",
|
||
singleDatabaseScopeHint: "Questo tipo di database supporta solo la protezione dell'ambiente di produzione a livello di connessione.",
|
||
databases: "Database di produzione",
|
||
connectionDescription: "Tutti i database su questa connessione avranno la protezione di produzione abilitata.",
|
||
databaseDescription: "Seleziona i database che necessitano di protezione di produzione dalla connessione. Alla prima apertura, sono selezionati tutti per impostazione predefinita.",
|
||
selectDatabases: "Seleziona database di produzione",
|
||
noDatabasesSelected: "Nessuno selezionato",
|
||
databasesConfiguredCount: "{count} selezionati",
|
||
databasesSelectedCount: "Selezionati {selected}/{total}",
|
||
databasePickerTitle: "Seleziona database di produzione",
|
||
databasePickerDescription: "Seleziona i database che necessitano di protezione di produzione in «{connection}».",
|
||
databaseSearchPlaceholder: "Cerca database...",
|
||
databaseSelectionRequired: "Selezionare almeno un database.",
|
||
databaseLoadFailed: "Impossibile caricare l'elenco dei database: {message}",
|
||
noDatabasesAvailable: "Nessun database selezionabile trovato.",
|
||
retry: "Riprova",
|
||
confirmTitle: "Conferma scrittura in ambiente di produzione",
|
||
confirmMessage: "Questa operazione modificherà il database di produzione; è necessario confermare esplicitamente per procedere.",
|
||
confirmDetails: "Connessione: {connection}\nDatabase: {database}\nOrigine: {source}",
|
||
confirmAction: "Esegui in ambiente di produzione",
|
||
sourceSqlEditor: "Editor SQL",
|
||
sourceDataGrid: "Editor dati",
|
||
sourceStructure: "Editor struttura",
|
||
sourceSqlFile: "Esecuzione file SQL",
|
||
sourceObjectBrowser: "Browser oggetti",
|
||
sourceSchemaDiff: "Confronto schema",
|
||
sourceDataCompare: "Confronto dati",
|
||
sourceExtension: "Gestione estensioni",
|
||
sourceSidebar: "Albero oggetti",
|
||
sourceObjectSource: "Editor sorgente oggetto",
|
||
sourceDataGenerate: "Generatore dati",
|
||
sourceQueryHistory: "Rollback cronologia query",
|
||
sourceAdmin: "Amministrazione database",
|
||
aiReviewRequired: "La SQL di produzione è stata inserita nell'editor. Controllare prima, quindi eseguire manualmente per confermare.",
|
||
},
|
||
processList: {
|
||
title: "Elenco processi",
|
||
sessionCount: "{count} sessioni",
|
||
filter: "Filtra sessioni",
|
||
autoRefresh: "Aggiornamento automatico",
|
||
seconds: "secondi",
|
||
colId: "Id",
|
||
colUser: "Utente",
|
||
colHost: "Host",
|
||
colDb: "Database",
|
||
colCommand: "Comando",
|
||
colTime: "Durata",
|
||
colState: "Stato",
|
||
colInfo: "SQL",
|
||
colActions: "Azioni",
|
||
self: "Corrente",
|
||
kill: "Termina",
|
||
cannotKillSelf: "Impossibile terminare la sessione corrente",
|
||
empty: "Nessuna sessione attiva.",
|
||
killTitle: "Termina sessione",
|
||
killConfirm: "Sei sicuro di voler terminare la sessione {id} ({user})? La dichiarazione corrente verrà interrotta e la connessione verrà chiusa.",
|
||
killSuccess: "Sessione {id} terminata",
|
||
killFailed: "Terminazione sessione non riuscita: {message}",
|
||
},
|
||
serverDashboard: {
|
||
title: "Dashboard del server",
|
||
autoRefresh: "Aggiornamento automatico",
|
||
off: "Spento",
|
||
qps: "Query al secondo",
|
||
connections: "Connessioni",
|
||
running: "Thread in esecuzione",
|
||
trafficIn: "Traffico in ingresso",
|
||
trafficOut: "Traffico in uscita",
|
||
slowQueries: "Query lente",
|
||
uptime: "Uptime",
|
||
innodbHit: "Percentuale di hit InnoDB",
|
||
in: "In",
|
||
out: "Out",
|
||
sessions: "Sessioni",
|
||
qpsChart: "Query al secondo",
|
||
sessionsChart: "Nuove sessioni al secondo",
|
||
trafficChart: "Traffico di rete al secondo",
|
||
commandChart: "Comandi al secondo",
|
||
rawStatus: "Variabili di stato",
|
||
filterStatus: "Filtra variabili di stato",
|
||
},
|
||
});
|