9245 lines
530 KiB
TypeScript
9245 lines
530 KiB
TypeScript
import { withEnglishFallback } from "./fallback";
|
||
import { meilisearchManagementKo } from "./meilisearchManagement";
|
||
import { redisGroupingKo as redisGrouping } from "./redisGrouping";
|
||
import docs from "./docs/ko";
|
||
import { consulKoMessages } from "./consulKo";
|
||
import { sqlServerTraceMessages as sqlServerTrace } from "./sqlServerTraceMessages";
|
||
|
||
const consul = {
|
||
...consulKoMessages,
|
||
redisGrouping,
|
||
prefixPlaceholder: "키 접두사, 예: app/ 또는 services/",
|
||
newKey: "새 키",
|
||
loadingKeys: "키 불러오는 중...",
|
||
empty: "키가 없습니다",
|
||
loadMore: "더 불러오기",
|
||
selectKey: "값을 보려면 키를 선택하세요",
|
||
loadingValue: "값 불러오는 중...",
|
||
notFound: "키를 찾을 수 없습니다",
|
||
edit: "편집",
|
||
editKey: "키 편집",
|
||
delete: "삭제",
|
||
deleteTitle: "Consul KV 키 삭제",
|
||
keyLabel: "키(Key)",
|
||
keyPlaceholder: "path/to/key",
|
||
keyRequired: "키를 입력하세요",
|
||
rootReadonly: "루트 접두사는 수정할 수 없습니다. 키 경로를 입력하세요.",
|
||
saved: "키가 저장되었습니다",
|
||
deleted: "키가 삭제되었습니다",
|
||
base64Readonly: "바이너리 값은 Base64 모드에서 편집하세요.",
|
||
rename: "이름 변경",
|
||
clone: "복제",
|
||
copyKey: "키 복사",
|
||
export: "내보내기",
|
||
value: "값",
|
||
valueContent: "값",
|
||
format: "형식",
|
||
metadata: "KV 메타데이터",
|
||
prettyJson: "보기 좋게 정렬",
|
||
invalidJson: "잘못된 JSON",
|
||
summarySize: "크기",
|
||
conflict: "불러온 후 키가 변경되었습니다. 새로 고친 후 다시 시도하세요.",
|
||
keyAlreadyExists: "같은 이름의 키가 이미 존재합니다. 다른 이름을 선택하거나 기존 키를 편집하세요.",
|
||
aclFiltered: "일부 Consul KV 키가 ACL 정책에 의해 숨겨져 있습니다.",
|
||
locked: "이 키는 Consul 세션이 보유하고 있어 편집하거나 삭제할 수 없습니다.",
|
||
valueTooLarge: "Consul KV 값은 512 KiB를 초과할 수 없습니다.",
|
||
watchKey: "감시",
|
||
stopWatching: "중지",
|
||
workspace: {
|
||
overview: "개요",
|
||
kv: "KV",
|
||
services: "서비스",
|
||
health: "상태",
|
||
sessions: "세션",
|
||
scope: "범위",
|
||
mesh: "서비스 메시",
|
||
tools: "도구",
|
||
operator: "운영 관리",
|
||
refresh: "기능 정보 새로 고침",
|
||
loading: "Consul 기능을 불러오는 중...",
|
||
agentIdentity: "에이전트 정보",
|
||
capabilities: "기능",
|
||
version: "버전",
|
||
edition: "에디션",
|
||
datacenter: "데이터센터",
|
||
node: "에이전트 노드",
|
||
mode: "에이전트 모드",
|
||
agent: "에이전트 API",
|
||
acl: "ACL",
|
||
namespaces: "네임스페이스",
|
||
partitions: "관리 파티션",
|
||
enterprise: "Enterprise",
|
||
community: "Community",
|
||
serverMode: "서버",
|
||
clientMode: "클라이언트",
|
||
capability: {
|
||
supported: "지원",
|
||
unsupported: "지원 안 함",
|
||
forbidden: "권한 없음",
|
||
unknown: "알 수 없음",
|
||
},
|
||
},
|
||
};
|
||
|
||
export default withEnglishFallback({
|
||
cellTransform: {
|
||
title: "변환 미리보기",
|
||
description: "현재 값을 변환하여 보거나 복사합니다. 원래 값과 편집 초안은 변경되지 않습니다.",
|
||
format: "변환 방식",
|
||
unit: "타임스탬프 단위",
|
||
timezone: "시간대",
|
||
pattern: "날짜 형식",
|
||
fromBase: "원본 진법",
|
||
toBase: "대상 진법",
|
||
convert: "변환",
|
||
result: "변환 결과",
|
||
copy: "결과 복사",
|
||
radixHint: "정수만 지원합니다. 0x, 0o, 0b 접두사 없이 입력하세요. 부호는 사용할 수 있습니다.",
|
||
urlHint: "URL 구성 요소를 UTF-8로 인코딩하거나 디코딩합니다. 디코딩 시 +를 공백으로 바꾸지 않습니다.",
|
||
kinds: {
|
||
timestamp: "타임스탬프 → 날짜/시간",
|
||
json: "JSON 서식 지정",
|
||
jsonCompact: "JSON 압축",
|
||
xml: "XML 서식 지정",
|
||
base64Encode: "텍스트 → Base64(UTF-8)",
|
||
base64Decode: "Base64 → 텍스트(UTF-8)",
|
||
urlEncode: "URL 구성 요소 인코딩",
|
||
urlDecode: "URL 구성 요소 디코딩",
|
||
radix: "정수 진법 변환",
|
||
},
|
||
units: {
|
||
auto: "자동(10/13자리)",
|
||
seconds: "초",
|
||
milliseconds: "밀리초",
|
||
},
|
||
errors: {
|
||
nullSource: "NULL에는 변환할 텍스트가 없습니다.",
|
||
incomplete: "전체 값을 아직 불러오지 못했습니다. 기다리거나 셀 상세 정보를 다시 여세요.",
|
||
unsafeNumber: "이 숫자는 안전하게 표현할 수 없습니다. 정밀도를 유지하려면 텍스트로 조회하세요.",
|
||
tooLarge: "변환 한도 초과: 입력 {maxInput}자, 출력 {maxOutput}자, 정수 입력 {maxRadixDigits}자입니다.",
|
||
invalid: "변환할 수 없습니다. 입력 형식과 변환 옵션을 확인하세요.",
|
||
invalidTimestamp: "지원하는 날짜 범위 내의 정수 타임스탬프를 입력하세요.",
|
||
ambiguousUnit: "단위를 확인할 수 없습니다. 초 또는 밀리초를 선택하세요.",
|
||
invalidInteger: "선택한 원본 진법에 맞는 정수를 접두사 없이 입력하세요.",
|
||
invalidBase64: "유효한 UTF-8 텍스트를 포함하는 표준 패딩 Base64를 입력하세요.",
|
||
},
|
||
},
|
||
customType: {
|
||
kinds: {
|
||
base: "기본형",
|
||
composite: "복합형",
|
||
domain: "도메인",
|
||
enum: "열거형",
|
||
range: "범위형",
|
||
multirange: "다중 범위형",
|
||
},
|
||
tabs: {
|
||
members: "멤버",
|
||
properties: "속성",
|
||
ddl: "DDL",
|
||
},
|
||
members: {
|
||
empty: "이 형식에는 멤버가 없습니다.",
|
||
name: "이름",
|
||
type: "형식",
|
||
nullable: "NULL 허용",
|
||
default: "기본값",
|
||
comment: "설명",
|
||
},
|
||
properties: {
|
||
empty: "사용 가능한 속성이 없습니다.",
|
||
baseType: "기본 형식",
|
||
notNull: "NULL 불가",
|
||
default: "기본값",
|
||
collation: "정렬 규칙",
|
||
domainConstraint: "제약 조건",
|
||
rangeSubtype: "범위 하위 형식",
|
||
rangeMultirange: "다중 범위 형식",
|
||
},
|
||
ddl: {
|
||
empty: "이 형식에 사용할 수 있는 DDL이 없습니다.",
|
||
incomplete: "생성된 DDL이 불완전하여 복사되지 않았습니다. 형식 세부 정보에서 경고를 확인하세요.",
|
||
},
|
||
},
|
||
app: {
|
||
name: "DBX",
|
||
},
|
||
docs,
|
||
pluginPlatform: {
|
||
openResultView: "{label}(으)로 열기",
|
||
centerTitle: "플러그인 센터",
|
||
centerDescription: "하나의 마켓플레이스에서 선택적 DBX 기능을 찾고, 설치된 플러그인과 저장소를 별도로 관리하세요.",
|
||
marketplace: "마켓플레이스",
|
||
installed: "설치됨",
|
||
settings: "설정",
|
||
searchMarketplace: "플러그인, 게시자 또는 태그 검색",
|
||
allRepositories: "모든 저장소",
|
||
marketplaceGuideTitle: "플러그인은 커뮤니티 개발자가 유지 관리합니다",
|
||
marketplaceGuideDescription: "플러그인 문제나 기능 제안은 플러그인 카드의 소스 저장소 링크를 통해 해당 저장소에 Issue를 등록해 주세요. DBX 메인 저장소는 앱 자체의 문제만 처리합니다.",
|
||
loadingMarketplace: "플러그인 마켓플레이스 로드 중",
|
||
noMarketplacePlugins: "표시할 플러그인이 없습니다",
|
||
noMarketplacePluginsDescription: "설정에서 저장소를 구성하거나 현재 검색 및 필터를 조정하세요.",
|
||
verified: "검증됨",
|
||
noDescription: "설명이 제공되지 않았습니다.",
|
||
permissionsCount: "권한 {count}개",
|
||
unsupportedTarget: "{target}에서는 사용할 수 없음",
|
||
installedVersion: "설치된 버전 v{version}",
|
||
licenseUnknown: "라이선스 미지정",
|
||
sourceRepository: "소스 저장소",
|
||
pluginHomepage: "홈페이지",
|
||
marketplaceStatus: {
|
||
install: "설치",
|
||
installed: "설치됨",
|
||
update: "업데이트",
|
||
unsupported: "지원되지 않음",
|
||
},
|
||
updateSuccess: "{name} 업데이트 완료: {version}",
|
||
noInstalledPlugins: "설치된 플러그인이 없습니다",
|
||
browseMarketplace: "마켓플레이스 둘러보기",
|
||
localInstallTitle: "플러그인 패키지 설치",
|
||
localInstallDescription: "마켓플레이스 외부에서 받은 서명된 .dbxp를 로컬 파일이나 URL에서 설치합니다. DBX가 패키지 무결성과 서명을 자동으로 검증합니다.",
|
||
repositoriesTitle: "플러그인 저장소",
|
||
repositoriesDescription: "공식 소스는 DBX에서 관리합니다. 자체 호스팅 또는 타사 저장소는 저장소 신뢰 설정을 사용합니다.",
|
||
repositoryFieldsRequired: "저장소 ID, 이름 및 카탈로그 URL은 필수입니다",
|
||
repositorySaved: "플러그인 저장소 '{name}'을 저장했습니다",
|
||
removeRepositoryConfirm: "플러그인 저장소 '{name}'을 제거하시겠습니까? 설치된 플러그인은 유지됩니다.",
|
||
repositoryRemoved: "플러그인 저장소 '{name}'을 제거했습니다",
|
||
repositoryKind: {
|
||
official: "공식",
|
||
custom: "사용자 지정",
|
||
enterprise: "엔터프라이즈",
|
||
},
|
||
repositoryNotConfigured: "이 빌드에는 카탈로그 URL이 구성되어 있지 않습니다",
|
||
enabled: "활성화됨",
|
||
disabled: "비활성화됨",
|
||
enable: "활성화",
|
||
disable: "비활성화",
|
||
repositoryIdPlaceholder: "저장소 ID",
|
||
repositoryNamePlaceholder: "저장소 이름",
|
||
repositoryCatalogUrlPlaceholder: "https://plugins.example.com/catalog/index.json",
|
||
addRepository: "저장소 추가",
|
||
signedPackagesVerifiedAutomatically: "서명이 자동으로 검증됩니다",
|
||
developerOptionsTitle: "타사 및 개발자 옵션",
|
||
developerOptionsDescription: "사용자 지정 저장소 또는 로컬 플러그인 개발에만 사용하세요.",
|
||
pluginDevelopmentDocsTitle: "플러그인 개발 문서",
|
||
pluginDevelopmentDocsDescription: "DBX 플러그인을 개발하고 패키징하여 마켓플레이스에 게시하는 방법을 알아보세요.",
|
||
pluginDevelopmentDocsOpen: "문서 보기",
|
||
developerOptionsWarning: "서명되지 않은 플러그인은 사용자 권한으로 네이티브 코드를 실행할 수 있습니다. 직접 빌드하고 신뢰하는 패키지에만 활성화하세요.",
|
||
connectionManagedInDialog: "통합된 새 연결 대화상자에서 연결을 만들고 편집하세요. 이 페이지는 플러그인 관리와 기능 표시에만 사용됩니다.",
|
||
allowUnsignedDevelopmentPackage: "서명되지 않은 개발 패키지 허용",
|
||
allowUnsignedDevelopmentPackageDescription: "수동 .dbxp 설치에만 적용되며 공식 마켓플레이스 검증은 완화하지 않습니다.",
|
||
installPackage: ".dbxp 설치",
|
||
installFromUrl: "URL에서 설치",
|
||
installUrlPlaceholder: "https://example.com/plugin.dbxp",
|
||
deepLinkInstallConfirm: "아래 링크에서 플러그인을 설치하시겠습니까?",
|
||
deepLinkInvalid: "잘못된 플러그인 설치 링크입니다: {message}",
|
||
invalidPackageUrl: "유효한 http(s) 플러그인 패키지 URL을 입력하세요",
|
||
downloadProgress: "다운로드 중 {downloaded} / {total}",
|
||
downloadProgressUnknown: "다운로드 중 {downloaded}",
|
||
dropToInstall: "놓아서 플러그인 패키지 설치",
|
||
dropInstallHint: ".dbxp 파일을 이 페이지에 끌어다 놓아도 설치할 수 있습니다",
|
||
packageFileType: "DBX 플러그인 패키지",
|
||
repositoryTrustTitle: "사용자 지정 저장소 신뢰",
|
||
repositoryTrustDescription: "사용자 지정 저장소 운영자는 하나의 저장소 키로 승인된 모든 패키지에 서명합니다. 별도의 신뢰할 수 있는 채널을 통해 공개 키를 받으세요.",
|
||
repositoryKeyAdded: "저장소 서명 키 '{keyId}'을 추가했습니다",
|
||
removeRepositoryKeyConfirm: "저장소 서명 키 '{keyId}'을 제거하시겠습니까? 설치된 플러그인은 유지됩니다.",
|
||
repositoryKeyRemoved: "저장소 서명 키 '{keyId}'을 제거했습니다",
|
||
repositoryKeyIdPlaceholder: "저장소 키 ID",
|
||
repositoryPublicKeyPlaceholder: "Base64 Ed25519 저장소 공개 키(32바이트)",
|
||
trustRepository: "저장소 신뢰",
|
||
noInstalledPluginsDescription: "서명된 .dbxp를 설치하거나 로컬 개발용 서명되지 않은 패키지를 명시적으로 허용하세요.",
|
||
compatible: "호환됨",
|
||
blocked: "차단됨",
|
||
rollback: "롤백",
|
||
uninstall: "제거",
|
||
rollbackConfirm: "이 플러그인을 이전 설치 버전으로 되돌리시겠습니까?",
|
||
rollbackSuccess: "{version}(으)로 롤백했습니다",
|
||
uninstallConfirm: "{name}을 제거하시겠습니까?",
|
||
uninstallSuccess: "{name}을 제거했습니다",
|
||
installSuccess: "{name} {version}을 설치했습니다",
|
||
selectConnectionProvider: "먼저 연결 제공자를 선택하세요",
|
||
connectionProvider: "연결 제공자",
|
||
newConnection: "새 연결",
|
||
workbenches: "워크벤치",
|
||
filesystemProviders: "파일 시스템 제공자",
|
||
open: "열기",
|
||
browse: "찾아보기",
|
||
parentDirectory: "상위 디렉터리",
|
||
filesystemUri: "파일 시스템 URI",
|
||
refresh: "새로 고침",
|
||
reloadRequired: "플러그인 페이지를 다시 로드해야 합니다.",
|
||
reloadHintPrefix: "",
|
||
reloadHintSuffix: " 키를 누르거나 아래 새로 고침 버튼을 클릭하세요.",
|
||
loadingFiles: "파일 로드 중",
|
||
emptyDirectory: "이 디렉터리는 비어 있습니다.",
|
||
loadMore: "더 불러오기",
|
||
fileManagerHint: "디렉터리를 두 번 클릭해 열거나 파일을 두 번 클릭해 최대 256KB까지 미리 봅니다.",
|
||
loadingPreview: "미리보기 로드 중",
|
||
previewTruncated: "미리보기가 256KB에서 잘렸습니다",
|
||
previewSelectedFileHint: "선택한 파일을 두 번 클릭해 미리보기를 로드하세요.",
|
||
entryCannotPreview: "이 항목은 미리 볼 수 없습니다.",
|
||
providerNoReadCapability: "제공자가 읽기 기능을 선언하지 않았습니다.",
|
||
filesystemUnavailable: "플러그인 파일 시스템 '{pluginId}/{providerId}'을 사용할 수 없습니다",
|
||
loadingFilesystem: "플러그인 파일 시스템 로드 중",
|
||
filesystemUnavailableFallback: "플러그인 파일 시스템을 사용할 수 없습니다",
|
||
workbenchUnavailable: "플러그인 워크벤치 '{pluginId}/{contributionId}'을 사용할 수 없습니다",
|
||
loadingWorkbench: "플러그인 워크벤치 로드 중",
|
||
workbenchUnavailableFallback: "플러그인 워크벤치를 사용할 수 없습니다",
|
||
pluginIncompatible: "플러그인이 호환되지 않습니다",
|
||
loadingTitle: "{title} 로드 중",
|
||
},
|
||
auth: {
|
||
rateLimited: "{seconds}초 후에 다시 시도해 주세요",
|
||
setupTitle: "접속 비밀번호 설정",
|
||
setupDescription: "인스턴스를 보호할 비밀번호를 설정하세요",
|
||
loginDescription: "데이터베이스 관리 도구",
|
||
newPassword: "새 비밀번호 입력",
|
||
confirmPassword: "비밀번호 확인",
|
||
enterPassword: "접속 비밀번호 입력",
|
||
passwordMismatch: "비밀번호가 일치하지 않습니다",
|
||
setPassword: "비밀번호 설정",
|
||
login: "로그인",
|
||
processing: "처리 중...",
|
||
loginFailed: "비밀번호가 올바르지 않습니다",
|
||
connectFailed: "연결에 실패했습니다",
|
||
changePassword: "비밀번호 변경",
|
||
oldPassword: "현재 비밀번호",
|
||
oldPasswordWrong: "현재 비밀번호가 올바르지 않습니다",
|
||
passwordChanged: "비밀번호가 변경되었습니다",
|
||
changePasswordFailed: "비밀번호 변경에 실패했습니다",
|
||
changePasswordDescription: "현재 비밀번호를 입력하고 새 비밀번호를 선택하세요",
|
||
},
|
||
toolbar: {
|
||
moreActions: "더 많은 작업",
|
||
newConnection: "새 연결",
|
||
newQuery: "새 쿼리",
|
||
execute: "실행",
|
||
executeShortcut: "선택 영역/쿼리 실행 ({shortcut})",
|
||
stopQuery: "쿼리 중지",
|
||
explainPlan: "실행 계획",
|
||
stopExplain: "실행 계획 중지",
|
||
autotrace: "자동 추적 (쿼리를 실행합니다)",
|
||
explainAnalyze: "EXPLAIN ANALYZE (쿼리를 실행합니다)",
|
||
actualPlan: "실제 실행 계획 (SET STATISTICS XML)",
|
||
formatSql: "SQL 정렬",
|
||
formatSqlFailed: "SQL 정렬에 실패했습니다",
|
||
formatAutoDetectFailed: "선택한 내용을 인식하거나 포맷할 수 없습니다",
|
||
compressSql: "SQL 압축",
|
||
keywordCaseLower: "SQL 키워드 소문자 사용",
|
||
keywordCaseUpper: "SQL 키워드 대문자 사용",
|
||
sqlSemanticDiagnosticsToggleOn: "SQL 의미 진단: 켜짐 (클릭하여 끄기)",
|
||
sqlSemanticDiagnosticsToggleOff: "SQL 의미 진단: 꺼짐 (클릭하여 켜기)",
|
||
insertValueHintsToggleOn: "INSERT 열 이름 힌트: 켜짐 (클릭하여 끄기)",
|
||
insertValueHintsToggleOff: "INSERT 열 이름 힌트: 꺼짐 (클릭하여 켜기)",
|
||
autoCommit: "자동 커밋",
|
||
manualTransaction: "수동 트랜잭션",
|
||
autoCommitAgent: "자동 커밋 (Agent 백엔드에 따라)",
|
||
manualTransactionAgent: "수동 트랜잭션 (Agent 백엔드에 따라)",
|
||
commit: "커밋",
|
||
rollback: "롤백",
|
||
txnAutoRolledBack: "5분간 활동이 없어 트랜잭션이 자동으로 롤백되었습니다",
|
||
previewSql: "SQL 미리보기",
|
||
previewQuery: "쿼리 미리보기",
|
||
hidePreviewSql: "SQL 미리보기 숨기기",
|
||
saveSql: "SQL 라이브러리에 저장",
|
||
openSql: "SQL 파일 열기",
|
||
exPasteSqlInCondition: "ExPaste: IN 조건으로 붙여넣기",
|
||
theme: "테마",
|
||
themeLight: "밝게",
|
||
themeDark: "어둡게",
|
||
themeSystem: "시스템 설정 따르기",
|
||
sqlSaved: "SQL이 저장되었습니다",
|
||
sqlOpenFailed: "파일을 여는 데 실패했습니다: {message}",
|
||
sqlSaveFailed: "파일을 저장하는 데 실패했습니다: {message}",
|
||
driverManager: "드라이버 관리자",
|
||
updatableDriverCount: "업데이트 가능한 드라이버 수",
|
||
mcpUpdateAvailable: "MCP 서버 업데이트 가능",
|
||
blockDangerousRedisCommands: "위험한 명령 차단",
|
||
saveSqlFile: "원본 파일에 저장",
|
||
pluginCenter: "플러그인 센터",
|
||
},
|
||
multiDbExecute: {
|
||
title: "다중 데이터베이스 실행",
|
||
progress: "실행 진행률 ({completed}/{total})",
|
||
sqlPreview: "SQL 미리보기",
|
||
databaseType: "데이터베이스 유형",
|
||
searchTargets: "연결, 데이터베이스, 스키마 검색...",
|
||
selectedCount: "{count}개 선택됨",
|
||
selectedTargets: "선택된 대상",
|
||
selectGroup: "실행 대상 그룹",
|
||
noGroupSelected: "대상 그룹 선택",
|
||
manageGroups: "그룹 관리",
|
||
manageGroupsDescription: "대상 그룹은 재사용 가능한 SQL 실행 대상이며 연결 그룹을 변경하지 않습니다.",
|
||
noGroups: "대상 그룹 없음",
|
||
loadGroup: "그룹 불러오기",
|
||
available: "사용 가능",
|
||
typeMismatch: "유형 불일치",
|
||
targets: "대상",
|
||
saveAsGroup: "그룹으로 저장",
|
||
saveChanges: "변경 사항 저장",
|
||
saveAsNewGroup: "새 그룹으로 저장",
|
||
renameGroup: "그룹 이름 변경",
|
||
deleteGroup: "그룹 삭제",
|
||
deleteGroupConfirm: "대상 그룹 “{name}”을(를) 삭제하시겠습니까? 연결과 데이터베이스에는 영향을 주지 않습니다.",
|
||
groupName: "그룹 이름",
|
||
groupNameRequired: "그룹 이름을 입력하세요.",
|
||
groupNameExists: "같은 이름의 그룹이 이미 있습니다.",
|
||
groupSaved: "대상 그룹 저장됨",
|
||
groupSaveFailed: "대상 그룹을 저장하지 못했습니다: {message}",
|
||
groupLoadFailed: "대상 그룹을 불러오지 못했습니다: {message}",
|
||
groupModified: "대상 선택이 변경됨",
|
||
unsavedChangesConfirm: "현재 대상 선택에 저장되지 않은 변경 사항이 있습니다. 계속하기 전에 저장하시겠습니까?",
|
||
cancelOperation: "작업 취소",
|
||
discardChanges: "변경 사항 버리기",
|
||
internalCatalog: "내부",
|
||
defaultDatabase: "기본 데이터베이스",
|
||
noDatabase: "연결 범위",
|
||
connectionOnlyTarget: "연결 수준 대상",
|
||
clearTargets: "지우기",
|
||
noTargets: "실행 가능한 대상이 없습니다.",
|
||
removeTarget: "대상 제거",
|
||
validTarget: "유효한 대상",
|
||
needsRecheck: "대상 검증 대기 중",
|
||
needsRecheckCount: "{count}개 대상에 검증이 필요합니다",
|
||
invalidTargetCount: "유효하지 않은 대상 {count}개",
|
||
invalidTarget: "유효하지 않은 대상",
|
||
targetMissingConnection: "연결이 더 이상 존재하지 않습니다",
|
||
targetTypeMismatch: "연결의 데이터베이스 유형이 더 이상 일치하지 않습니다",
|
||
targetCatalogMissing: "카탈로그가 더 이상 존재하지 않습니다",
|
||
targetDatabaseMissing: "데이터베이스가 없거나 접근할 수 없습니다",
|
||
targetSchemaMissing: "스키마가 없거나 접근할 수 없습니다",
|
||
targetPermissionDenied: "대상을 검증할 권한이 없습니다",
|
||
targetValidationFailed: "대상 검증 실패",
|
||
retryValidation: "검증 다시 시도",
|
||
serialContinueOnError: "직렬 실행, 실패 후에도 계속",
|
||
parallelContinueOnError: "병렬 실행, 실패 후에도 계속",
|
||
serial: "직렬",
|
||
parallel: "병렬",
|
||
switchToParallel: "병렬로 전환",
|
||
switchToSerial: "직렬로 전환",
|
||
elapsed: "경과 시간: {duration}",
|
||
pending: "대기 중",
|
||
running: "실행 중",
|
||
success: "성공",
|
||
failed: "실패",
|
||
skipped: "건너뜀",
|
||
cancelled: "취소됨",
|
||
notExecuted: "실행되지 않음",
|
||
execute: "실행",
|
||
cancelBatch: "일괄 실행 취소",
|
||
dangerTitle: "대상 실행 확인",
|
||
dangerConfirm: "이 대상에서 실행",
|
||
resultTabPrefix: "다중 DB",
|
||
},
|
||
externalSqlFile: {
|
||
modifiedTitle: "DBX 외부에서 파일이 변경됨",
|
||
modifiedDescription: "{path} 파일이 다른 프로그램에서 변경되었습니다. 유지할 버전을 선택하세요.",
|
||
deletedTitle: "파일이 더 이상 존재하지 않음",
|
||
deletedDescription: "{path} 파일이 DBX 외부에서 삭제되거나 이동되었습니다. 편집기 내용은 유지됩니다.",
|
||
unsavedWarning: "편집기에도 저장되지 않은 변경 사항이 있습니다. 외부 버전을 불러오면 해당 변경 사항이 사라집니다.",
|
||
deletedUnsavedWarning: "편집기에 저장되지 않은 변경 사항이 있습니다. 탭을 닫으면 해당 변경 사항이 사라집니다.",
|
||
keepEditor: "편집기 내용 유지",
|
||
loadLatest: "최신 버전 불러오기",
|
||
cancelSave: "저장 취소",
|
||
loadExternal: "외부 버전 불러오기",
|
||
overwriteSave: "파일 덮어쓰기",
|
||
keepEditing: "계속 편집",
|
||
saveAs: "다른 이름으로 저장...",
|
||
recreate: "파일 다시 만들기",
|
||
closeTab: "탭 닫기",
|
||
loadFailed: "파일의 최신 내용을 불러오지 못했습니다: {message}",
|
||
checkFailed: "외부 SQL 파일을 확인하지 못했습니다: {message}",
|
||
changedAgain: "저장하는 동안 파일이 다시 변경되었습니다. 다시 시도하세요.",
|
||
},
|
||
updates: {
|
||
preparationWindowOperation: "업데이트하기 전에 현재 창 작업이 완료될 때까지 기다려 주세요.",
|
||
preparationBusy: "업데이트를 준비 중입니다.",
|
||
preparationCancelled: "업데이트 준비가 취소되었습니다.",
|
||
preparationTimeout: "창이 5초 안에 저장되지 않았습니다. 다시 시도하세요.",
|
||
preparationWindowsChanged: "열린 창이 변경되었습니다. 다시 시도하세요.",
|
||
preparationTasks: "실행 중인 작업과 트랜잭션을 종료하세요.",
|
||
preparationDrafts: "변경 사항을 저장하거나 버리세요.",
|
||
preparationConfig: "현재 설정 편집을 완료하세요.",
|
||
preparationNotReady: "업데이트 준비가 안 되었습니다. 다시 시도하세요.",
|
||
downloadedReady: "새 버전 v{version} 다운로드 완료. 다시 시작하여 업데이트하세요.",
|
||
restartAndUpdate: "다시 시작 및 업데이트",
|
||
preparing: "업데이트 준비 중…",
|
||
retryDownload: "다운로드 재시도",
|
||
title: "업데이트",
|
||
check: "업데이트 확인",
|
||
checking: "업데이트 확인 중…",
|
||
updateReadyTooltip: "업데이트 준비 완료 — 클릭하여 설치",
|
||
restartRequiredTooltip: "업데이트 설치 완료 — 다시 시작하여 완료하세요",
|
||
availableTitle: "업데이트 가능",
|
||
availableMessage: "DBX {latest}을(를) 사용할 수 있습니다. 현재 {current}을(를) 사용 중입니다.",
|
||
upToDate: "DBX가 최신 버전입니다 ({version}).",
|
||
failed: "업데이트 확인에 실패했습니다: {error}",
|
||
rateLimited: "GitHub 업데이트 확인이 일시적으로 제한되었습니다. 릴리스 페이지를 직접 열어 수동으로 확인할 수 있습니다.",
|
||
openRelease: "릴리스 열기",
|
||
ignoreVersion: "이 버전 무시",
|
||
versionIgnored: "{version} 버전을 무시했습니다. 다음 버전이 출시되면 다시 알려드립니다.",
|
||
ignoreVersionFailed: "무시할 버전을 저장하지 못했습니다: {error}",
|
||
downloadInBackground: "백그라운드에서 다운로드",
|
||
cancelDownload: "다운로드 취소",
|
||
downloadStarted: "DBX {version}을(를) 백그라운드에서 다운로드하고 있습니다.",
|
||
activeTasksBlockUpdate: "{count}개의 작업이 아직 실행 중입니다. DBX를 업데이트하려면 작업이 완료될 때까지 기다려 주세요.",
|
||
portableAutomaticUpdate: "DBX가 서명된 휴대용 ZIP을 다운로드하여 종료 후 DBX.exe만 교체하고 자동으로 다시 시작합니다. portable.dbx와 데이터는 보존됩니다.",
|
||
windows7ManualUpdate: "Windows 7은 전용 WebView2 109 오프라인 설치 프로그램이 필요합니다. 릴리스 페이지를 열어 Windows 7 패키지를 다운로드하여 업데이트하세요.",
|
||
downloading: "다운로드 중 {progress}%",
|
||
downloadFailed: "업데이트 다운로드에 실패했습니다: {error}",
|
||
downloadCanceled: "업데이트 다운로드가 취소되었습니다.",
|
||
readyToInstall: "DBX {version} 설치 준비가 완료되었습니다.",
|
||
installNow: "지금 설치",
|
||
installedReadyToRestart: "DBX가 업데이트되었습니다. 다시 시작하여 완료하세요.",
|
||
networkOrMirrorFailed: "네트워크 연결 시간이 초과되었거나 다운로드 미러에 연결할 수 없습니다. 네트워크를 확인하거나 '릴리스 열기'를 클릭하여 수동으로 다운로드하세요.",
|
||
installing: "업데이트 설치 중...",
|
||
installFailed: "업데이트 설치에 실패했습니다: {error}",
|
||
restart: "종료 후 다시 시작",
|
||
restartFailed: "앱을 다시 시작하는 데 실패했습니다: {error}",
|
||
exitAndUpdate: "종료 후 업데이트",
|
||
dockerUsersRun: "Docker 사용자는 다음 명령을 실행하세요",
|
||
toUpdate: "업데이트하려면",
|
||
source: "업데이트 소스",
|
||
sourceOfficial: "공식 소스",
|
||
sourceCnb: "CNB",
|
||
},
|
||
sidebar: {
|
||
connections: "연결",
|
||
noConnections: "아직 연결이 없습니다",
|
||
importExport: "가져오기 / 내보내기",
|
||
import: "연결 가져오기",
|
||
importDbx: "DBX 설정 가져오기",
|
||
importNavicat: "Navicat NCX 가져오기",
|
||
importDbeaver: "DBeaver 가져오기",
|
||
importDatagrip: "DataGrip 가져오기",
|
||
export: "연결 내보내기",
|
||
collapseAll: "모두 접기",
|
||
collapse: "사이드바 접기",
|
||
expand: "사이드바 펼치기",
|
||
showMore: "{count}개 더 보기...",
|
||
filterByType: "유형별로 필터",
|
||
showActiveConnectionsOnly: "활성 연결만 표시",
|
||
activeConnectionsStatus: "활성 연결: {count}",
|
||
disconnectAllActiveConnections: "모든 활성 연결 끊기",
|
||
sortConnections: "연결 정렬",
|
||
sortConnectionsManual: "수동 순서",
|
||
sortConnectionsAscending: "이름: 가나다순",
|
||
sortConnectionsDescending: "이름: 다나가순",
|
||
searchScopeConnection: "연결",
|
||
searchScopeDatabase: "데이터베이스",
|
||
searchScopeSchema: "스키마",
|
||
searchScopeTable: "테이블",
|
||
searchScopeView: "뷰",
|
||
searchTablesInCurrentScope: "이 데이터베이스에서 테이블 검색...",
|
||
clearTableSearch: "테이블 검색 지우기",
|
||
regexSearch: "정규식 검색",
|
||
regexSearchTooltip: "JavaScript 정규식으로 사이드바 이름, 주석, 별칭을 검색합니다.",
|
||
clearFilter: "필터 지우기",
|
||
locateActiveTab: "사이드바에서 찾기",
|
||
},
|
||
savedSql: {
|
||
saveToLibrary: "SQL 라이브러리에 저장",
|
||
saveToFile: "로컬에 저장",
|
||
save: "저장",
|
||
saved: "SQL이 저장되었습니다",
|
||
saveFailed: "SQL 저장에 실패했습니다: {message}",
|
||
fileName: "파일 이름",
|
||
folder: "폴더",
|
||
rootFolder: "SQL 라이브러리",
|
||
newQuery: "새 쿼리",
|
||
newFolder: "새 SQL 폴더",
|
||
newSubfolder: "새 하위 폴더",
|
||
newFolderDefault: "새 폴더",
|
||
renameFolder: "폴더 이름 변경",
|
||
deleteFolder: "폴더 삭제",
|
||
deleteFolderConfirm: "“{name}”과(와) 그 안의 SQL 파일을 삭제하시겠습니까?",
|
||
open: "SQL 열기",
|
||
copyFile: "SQL 복사",
|
||
pasteFile: "SQL 붙여넣기",
|
||
copied: "SQL {count}개를 복사했습니다",
|
||
pasted: "SQL {count}개를 붙여넣었습니다",
|
||
nothingToPaste: "붙여넣을 SQL이 없습니다",
|
||
pasteFailed: "SQL 붙여넣기 실패: {message}",
|
||
renameFile: "SQL 이름 변경",
|
||
renameFailed: "SQL 이름 변경 실패: {message}",
|
||
nameConflict: '이 위치에 "{name}"이라는 SQL이 이미 있습니다',
|
||
deleteFile: "SQL 삭제",
|
||
deleteFileConfirm: "“{name}”을(를) 삭제하시겠습니까?",
|
||
createFolderOption: "폴더 “{name}” 만들기",
|
||
folderPlaceholder: "폴더를 선택하세요",
|
||
searchPlaceholder: "폴더 검색...",
|
||
createFolderFailed: "폴더 만들기에 실패했습니다: {message}",
|
||
},
|
||
sqlLibrary: {
|
||
title: "SQL 라이브러리",
|
||
storageHelp: "SQL 라이브러리 내용은 디스크의 독립된 .sql 파일이 아니라 DBX 앱 데이터에 저장됩니다.\n파일 시스템에서 사용하려면 SQL 라이브러리를 내보내세요.",
|
||
unassociated: "연결되지 않음",
|
||
deletedConnection: "삭제된 연결",
|
||
openInCurrentDatabase: "현재 데이터베이스에서 열기",
|
||
empty: "아직 저장된 쿼리가 없습니다",
|
||
emptyFolder: "빈 폴더",
|
||
unfiled: "분류 안 됨",
|
||
exportFile: "SQL 내보내기",
|
||
exportFolder: "폴더 내보내기",
|
||
exportLibrary: "SQL 라이브러리 내보내기",
|
||
importDirectory: "로컬 폴더 가져오기",
|
||
importIntoFolder: "폴더로 가져오기",
|
||
openStorageDirectory: "SQL 저장 디렉터리 열기",
|
||
chooseSyncDirectory: "로컬 동기화 디렉터리 설정",
|
||
disableSyncDirectory: "로컬 동기화 디렉터리 비활성화",
|
||
syncDirectorySaved: "SQL 로컬 동기화 디렉터리가 저장되었습니다",
|
||
syncDirectoryDisabled: "SQL 로컬 동기화가 비활성화되었습니다",
|
||
syncDirectoryFailed: "동기화 디렉터리 설정에 실패했습니다: {message}",
|
||
openDirectoryFailed: "디렉터리를 여는 데 실패했습니다: {message}",
|
||
noSyncDirectory: "먼저 로컬 동기화 디렉터리를 설정하세요",
|
||
exported: "내보냈습니다",
|
||
exportFailed: "내보내기에 실패했습니다: {message}",
|
||
importFailed: "가져오기에 실패했습니다: {message}",
|
||
importNone: "선택한 폴더에 .sql 파일이 없습니다",
|
||
imported: "SQL 파일 {count}개를 가져왔습니다",
|
||
desktopOnly: "이 기능은 데스크톱에서만 사용할 수 있습니다",
|
||
noConnection: "가져오기에 사용할 수 있는 연결이 없습니다",
|
||
batchDelete: "일괄 삭제",
|
||
batchDeleteConfirm: "선택한 항목 {count}개를 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.",
|
||
batchDeleteSuccess: "항목 {count}개를 삭제했습니다",
|
||
moveToFolder: "폴더로 이동...",
|
||
moveSelectedToFolder: "SQL {count}개를 폴더로 이동...",
|
||
moveSuccess: "SQL 파일 {count}개를 이동했습니다",
|
||
moveFailed: "SQL 이동 실패: {message}",
|
||
clearSelection: "선택 해제",
|
||
sortByDate: "수정 날짜순 정렬",
|
||
sortByFolder: "폴더 구조순 정렬",
|
||
collapseAll: "모두 접기",
|
||
},
|
||
connection: {
|
||
title: "새 연결",
|
||
name: "이름",
|
||
namePlaceholder: "연결 이름, 비워두면 자동 생성",
|
||
note: "메모",
|
||
noteShow: "표시",
|
||
noteShowInSidebar: "연결 목록에 메모 표시",
|
||
notePlaceholder: "메모에 비밀번호를 평문으로 저장하지 마세요",
|
||
type: "유형",
|
||
host: "호스트",
|
||
addHost: "호스트 추가",
|
||
filePath: "파일 경로",
|
||
h2FileMode: "파일",
|
||
h2TcpMode: "TCP",
|
||
h2FilePathRequired: "H2 파일 경로는 비워둘 수 없습니다",
|
||
createDuckDbFile: "DuckDB 파일 만들기",
|
||
createSqliteFile: "SQLite 데이터베이스 만들기",
|
||
memoryDatabasePathHint: "인메모리 SQLite 또는 DuckDB 데이터베이스를 만들려면 :memory:를 사용하세요.",
|
||
sqliteCipherKey: "SQLite 암호화 키",
|
||
sqliteCipherKeyPlaceholder: "암호화하지 않은 SQLite는 비워 두세요",
|
||
sqliteExtensions: "SQLite 확장",
|
||
sqliteExtensionsPlaceholder: "/path/to/regexp.dylib\n/path/to/text.dylib|sqlite3_text_init",
|
||
sqliteExtensionsHint: "한 줄에 하나의 .dylib/.so/.dll. 진입점이 필요할 때 “path|entry point”를 사용하세요. 연결 시 로드되며, 그 후 load_extension이 비활성화됩니다.",
|
||
initScript: "초기화 스크립트",
|
||
initScriptPlaceholder: "INSTALL quack;\nLOAD quack;\nATTACH 'quack:host' AS remote (TOKEN '...');",
|
||
initScriptHint: "연결이 열릴 때마다 실행되는 SQL 구문 (INSTALL/LOAD, SET, CREATE SECRET, ATTACH ...). 여기서 연결한 데이터베이스는 사이드바에 나타납니다.",
|
||
sqliteExtensionBrowse: "SQLite 확장 선택",
|
||
user: "사용자",
|
||
password: "비밀번호",
|
||
dynamodbEndpoint: "엔드포인트",
|
||
dynamodbRegion: "리전",
|
||
dynamodbAccessKeyId: "액세스 키 ID",
|
||
dynamodbSecretAccessKey: "비밀 액세스 키",
|
||
dynamodbSessionToken: "세션 토큰",
|
||
dynamodbSessionTokenPlaceholder: "선택",
|
||
dynamodbCredentialsRequired: "DynamoDB에는 액세스 키 ID와 비밀 액세스 키가 필요합니다",
|
||
savePassword: "비밀번호 저장",
|
||
savePasswordHint: "비밀번호를 저장하여 다음 연결부터 다시 입력하지 않아도 됩니다.",
|
||
savePasswordSessionHint: "비밀번호는 이번 실행 동안만 유지되며 앱을 종료하면 삭제됩니다.",
|
||
disconnectAndForgetPassword: "연결 끊고 비밀번호 잊기",
|
||
passwordForgotten: "비밀번호를 잊었습니다. 다음 연결 시 다시 입력해야 합니다.",
|
||
promptPasswordTitle: "비밀번호 입력",
|
||
promptPasswordMessage: "연결 “{connection}”의 비밀번호를 입력하세요. 빈 비밀번호라면 바로 연결할 수 있습니다.",
|
||
promptPasswordPlaceholder: "비밀번호",
|
||
promptPasswordSubmit: "연결",
|
||
promptPasswordCancel: "취소",
|
||
promptRememberPassword: "비밀번호 기억",
|
||
rememberPasswordSaveFailed: "연결되었지만 DBX가 비밀번호를 저장하지 못했습니다: {message}",
|
||
mysqlMissingPasswordHint: "데이터베이스 비밀번호가 전송되지 않았습니다. 비밀번호를 입력한 후 다시 시도하세요.",
|
||
database: "데이터베이스",
|
||
databasePlaceholder: "선택",
|
||
databasePlaceholderRequired: "필수, 기존 데이터베이스 입력",
|
||
databasePlaceholderWithDefault: "선택, 기본값 {database}",
|
||
kingbaseDatabaseRequired: "KingbaseES는 연결이나 데이터베이스 목록을 불러오기 전에 기존 데이터베이스가 필요합니다.",
|
||
defaultDatabase: "기본 DB",
|
||
authDatabase: "인증 DB",
|
||
authDatabasePlaceholder: "선택, 보통 admin",
|
||
authMechanism: "인증 방식",
|
||
authMechanismDefault: "기본",
|
||
oidcBrowserAuthHint: "연결할 때 시스템 브라우저에서 인증을 완료하며 데이터베이스 비밀번호는 필요하지 않습니다.",
|
||
driverMode: "드라이버",
|
||
mongoDriverAuto: "자동",
|
||
mongoDriverLegacy: "레거시",
|
||
serviceName: "서비스/SID",
|
||
serviceNameOnly: "서비스 이름",
|
||
oracleTnsAlias: "네트워크 별칭",
|
||
oracleTnsAliasPlaceholder: "tnsnames.ora의 별칭",
|
||
oracleTnsAdminPlaceholder: "tnsnames.ora가 있는 디렉터리",
|
||
oracleTnsAdminBrowse: "tnsnames.ora 선택",
|
||
oracleTnsPathHint: "DBX 백엔드/Oracle 에이전트가 이 경로를 읽습니다. 데스크톱 경로는 로컬이며, Web과 Docker 경로는 서버에 있습니다.",
|
||
oracleTnsAliasRequired: "Oracle TNS 모드에는 네트워크 별칭이 필요합니다.",
|
||
oracleTnsAdminRequired: "Oracle TNS 모드에는 tnsnames.ora가 포함된 TNS_ADMIN 디렉터리가 필요합니다.",
|
||
oracleTnsTransportUnsupported: "Oracle TNS 연결은 SSH, 프록시 또는 HTTP 터널 계층을 사용할 수 없습니다. 전송 계층을 제거하거나 서비스 이름/SID 모드를 사용하세요.",
|
||
igniteVersion: "Ignite 버전",
|
||
elasticsearchDirectMode: "직접",
|
||
elasticsearchKibanaProxyMode: "Kibana 프록시",
|
||
elasticsearchKibanaHost: "Kibana 호스트",
|
||
elasticsearchKibanaBasePath: "기본 경로",
|
||
elasticsearchConnectivityCheckPath: "연결 확인 경로",
|
||
elasticsearchConnectivityCheckPathPlaceholder: "/ 또는 /my-index/_search",
|
||
elasticsearchConnectivityCheckDisabled: "Disable connectivity check",
|
||
elasticsearchConnectivityCheckDisabledHint: "When on, connect and test skip the probe request and treat the server as reachable. Use it when the account lacks permission for the root path and any check path, or when permissions differ across clusters.",
|
||
elasticsearchIndexGroupingPattern: "Index grouping regex",
|
||
elasticsearchIndexGroupingPatternPlaceholder: "off by default; enter a regex to enable",
|
||
elasticsearchIndexGroupingPatternHint: "Off by default (naming schemes vary). Enter a regular expression to enable: matched rolling or time-series indices are aggregated into one queryable wildcard pattern, hiding per-day detail.",
|
||
version: "버전",
|
||
victoriametricsApiPath: "API 경로",
|
||
victoriametricsApiPathHint: "단일 노드 배포에는 /prometheus를, 클러스터에는 /select/tenantID/prometheus를 사용하세요.",
|
||
victoriametricsLookback: "메타데이터 조회 범위",
|
||
victoriametricsLookbackHint: "메트릭 및 레이블 열 검색에 사용합니다(예: 1h 또는 7d). 메트릭 미리보기는 1h를 사용하며 쿼리를 편집할 수 있습니다.",
|
||
victoriametricsInvalidApiPath: "VictoriaMetrics API 경로는 비워 두거나 /로 시작해야 합니다.",
|
||
victoriametricsInvalidLookback: "VictoriaMetrics 조회 범위가 올바르지 않습니다. 15m, 1h 또는 7d와 같은 값을 사용하세요.",
|
||
driverInstallHintPrefix: "연결 전에 상단 도구 모음의 ",
|
||
driverInstallHintSuffix: "에서 필수 드라이버를 설치하세요.",
|
||
driverName: "드라이버 이름",
|
||
driverNamePlaceholder: "공급자 또는 환경 이름",
|
||
urlParams: "URL 매개변수",
|
||
localInfilePathHint: "For LOAD DATA LOCAL INFILE, whitelist each file explicitly with localInfilePath=/absolute/path/file.csv. Repeat the parameter for additional files.",
|
||
d1AccountId: "계정 ID",
|
||
d1DatabaseId: "데이터베이스 ID",
|
||
d1ApiToken: "API 토큰",
|
||
d1TokenHint: "토큰에는 D1 Read 권한이 필요하며, 쓰기, DDL 및 가져오기에는 D1 Write도 필요합니다.",
|
||
d1FieldsRequired: "Cloudflare 계정 ID, D1 데이터베이스 ID 및 API 토큰은 필수입니다.",
|
||
spannerStructuredMode: "리소스 ID",
|
||
spannerResourcePathMode: "리소스 경로",
|
||
spannerProject: "프로젝트 ID",
|
||
spannerInstance: "인스턴스 ID",
|
||
spannerDatabase: "데이터베이스 ID",
|
||
spannerResourcePathHint: "projects/my-project/instances/my-instance/databases/my-database",
|
||
spannerHostHint: "Google Cloud에 연결할 때는 호스트를 비워 둡니다. 로컬 에뮬레이터는 호스트를 localhost, 포트를 9010으로만 지정하면 되며, 루프백 호스트에서는 일반 텍스트 gRPC가 자동으로 활성화됩니다.",
|
||
spannerCredentialsHint: "인증은 Application Default Credentials를 사용합니다. 서비스 계정 키 파일을 사용하려면 URL 매개변수에 credentials=/path/key.json을 추가하세요.",
|
||
spannerFieldsRequired: "Cloud Spanner 프로젝트, 인스턴스, 데이터베이스는 필수입니다.",
|
||
hiveAuthMode: "인증",
|
||
hiveAuthNone: "없음",
|
||
hivePrincipal: "프린시펄",
|
||
hiveKerberosPrincipalRequired: "Kerberos 프린시펄은 필수입니다",
|
||
hiveKrb5ConfBrowse: "krb5.conf 선택",
|
||
hiveJaasConfigBrowse: "JAAS 구성 선택",
|
||
hiveTicketCache: "티켓 캐시",
|
||
hiveTicketCacheFallback: "useSubjectCredsOnly=false 설정",
|
||
hiveJvmOptions: "JVM 옵션",
|
||
hiveJvmOptionsPlaceholder: "-Dsun.security.krb5.debug=true",
|
||
gbaseServer: "GBASEDBTSERVER",
|
||
gbaseServerHint: "서버의 DBSERVERNAME 또는 DBSERVERALIASES와 일치해야 합니다.",
|
||
gbaseServerMismatch: "GBase 8s 연결 실패: GBASEDBTSERVER가 서버의 DBSERVERNAME 또는 DBSERVERALIASES와 일치하지 않습니다. 연결 설정에 실제 서버 이름을 입력하세요.",
|
||
informixServer: "INFORMIXSERVER",
|
||
sslEnable: "암호화된 연결 사용",
|
||
caCertPath: "CA 인증서",
|
||
caCertPathPlaceholder: "선택, 예: ~/.yandex/RootCA.crt",
|
||
caCertPathBrowse: "인증서 찾아보기",
|
||
cassandraTruststore: "트러스트스토어",
|
||
cassandraTruststorePlaceholder: "/path/to/client.truststore",
|
||
cassandraTruststorePassword: "트러스트스토어 비밀번호",
|
||
cassandraTruststoreBrowse: "Cassandra 트러스트스토어 선택",
|
||
cassandraTruststoreHint: "Cassandra 서버 인증서를 검증하는 JKS 또는 PKCS#12 트러스트스토어.",
|
||
cassandraTruststorePasswordRequiresPath: "비밀번호를 입력하기 전에 Cassandra 트러스트스토어를 먼저 선택하세요.",
|
||
cassandraKeystore: "클라이언트 키스토어",
|
||
cassandraKeystorePlaceholder: "/path/to/client.keystore",
|
||
cassandraKeystorePassword: "키스토어 비밀번호",
|
||
cassandraKeystoreBrowse: "Cassandra 클라이언트 키스토어 선택",
|
||
cassandraKeystoreHint: "클라이언트 인증서 인증용 선택적 JKS / PKCS#12 키스토어.",
|
||
cassandraKeystorePasswordRequiresPath: "비밀번호를 입력하기 전에 Cassandra 클라이언트 키스토어를 먼저 선택하세요.",
|
||
damengSslFilesPath: "인증서 디렉터리",
|
||
damengSslFilesPathPlaceholder: "/path/to/dmcert",
|
||
damengSslFilesPathBrowse: "인증서 디렉터리 선택",
|
||
damengSslKeystorePassword: "키스토어 비밀번호",
|
||
damengSslHint: "DM8 JDBC는 이 디렉터리에서 SSL 인증서를 읽고 두 필드를 URL 매개변수로 전달합니다.",
|
||
damengSslProtocol: "SSL 프로토콜",
|
||
damengSslProtocolPlaceholder: "선택, 예: TLSv1.2",
|
||
damengSslVerificationHint: "인증서 검증은 DM8 서버 ENABLE_ENCRYPT 설정으로 제어됩니다. 모드 5는 서버 인증서를 검증하며, 모드 4는 인증서 검증 없이 암호화합니다.",
|
||
damengJvmOptions: "JVM 시스템 속성",
|
||
damengJvmOptionsPlaceholder: "-Djava.net.preferIPv4Stack=true",
|
||
damengJvmOptionsHint: "한 줄에 하나의 -Dkey 또는 -Dkey=value. 공백이 있는 값에는 셸 인용 부호가 필요하지 않습니다.",
|
||
damengJvmOptionsInvalid: "{line}번째 줄은 셸 인용 부호 없는 -Dkey 또는 -Dkey=value 시스템 속성이어야 합니다.",
|
||
damengBuiltinDriver: "내장 DM8",
|
||
damengCustomDriver: "DM6 / 사용자 지정 JAR",
|
||
damengDriverModeHint: "DM8은 내장 드라이버를 사용합니다. DM6 또는 다른 호환 버전은 해당 공식 JDBC JAR을 선택하세요.",
|
||
damengCustomDriverHint: "정식 출처의 Dameng JDBC JAR을 선택하세요. 사용자 지정 드라이버는 Dameng 에이전트에서 격리되어 로드되며 일반 JDBC 플러그인이 필요하지 않습니다.",
|
||
damengCustomDriverRequired: "Dameng JDBC 드라이버 JAR을 선택하세요.",
|
||
redisTlsInsecure: "인증서 검증 건너뛰기",
|
||
redisTlsInsecureHint: "redis-cli --tls --insecure과 동일하며, 자체 서명 인증서나 사설 CA용입니다.",
|
||
mysqlTlsMode: "TLS 모드",
|
||
mysqlTlsModePreferred: "선호",
|
||
mysqlTlsModeDisabled: "비활성화",
|
||
mysqlTlsModeRequired: "필수",
|
||
mysqlTlsModeVerifyCa: "CA 확인",
|
||
mysqlTlsModeVerifyIdentity: "ID 확인",
|
||
mysqlCleartextPasswordAuth: "평문 비밀번호 인증",
|
||
mysqlCleartextPasswordAuthHint: "MySQL 서버가 평문 비밀번호 인증 플러그인을 요구할 때만 활성화하세요.",
|
||
mysqlCaCertHint: "서버 인증서가 사설 CA를 사용할 때 CA 확인과 ID 확인에 필요합니다.",
|
||
mysqlClientCert: "클라이언트 인증",
|
||
mysqlClientCertPlaceholder: "/path/to/client.crt",
|
||
mysqlClientKeyPlaceholder: "/path/to/client.key",
|
||
mysqlClientCertHint: "MySQL이 mTLS를 요구할 때 클라이언트 인증서와 개인 키를 함께 제공해야 합니다.",
|
||
mysqlTlsConnectionFailureHint: "MySQL 서버가 TLS를 요구하지 않으면 연결을 편집하여 TLS 모드를 비활성화로 설정하고 다시 시도하세요.",
|
||
mysqlUnsupportedCertVersionHint: "엄격한 검증은 이 서버 인증서 버전을 지원하지 않습니다. X.509 v3 인증서로 교체하거나 신뢰할 수 있는 네트워크에서만 필수 모드를 사용하세요.",
|
||
mysqlClientCertBrowse: "클라이언트 인증서 선택",
|
||
mysqlClientKeyBrowse: "클라이언트 개인 키 선택",
|
||
postgresSslMode: "TLS 모드",
|
||
postgresSslModeDisable: "비활성화",
|
||
postgresSslModePrefer: "선호",
|
||
postgresSslModeRequire: "필수",
|
||
postgresSslModeVerifyCa: "CA 확인",
|
||
postgresSslModeVerifyFull: "전체 확인",
|
||
postgresLegacyTls: "레거시 TLS 호환성",
|
||
postgresLegacyTlsHint: "TLS 1.2 정적 RSA 키 교환만 지원하는 서버와의 연결을 지원합니다. 기본 모드보다 보안 수준이 낮으므로 서버 TLS 구성을 업그레이드할 수 없는 경우에만 활성화하세요.",
|
||
postgresServerCert: "서버 CA",
|
||
postgresRootCertPlaceholder: "/path/to/ca.crt",
|
||
postgresRootCertHint: "서버 인증서가 사설 CA로 서명된 경우 verify-ca 또는 verify-full에 사용하세요.",
|
||
postgresRootCertBrowse: "CA 인증서 선택",
|
||
postgresClientCert: "클라이언트 인증",
|
||
postgresClientCertPlaceholder: "/path/to/client.crt",
|
||
postgresClientKeyPlaceholder: "/path/to/client.key",
|
||
postgresClientCertHint: "PostgreSQL이 mTLS를 요구할 때 클라이언트 인증서와 개인 키를 함께 제공해야 합니다.",
|
||
postgresClientCertBrowse: "클라이언트 인증서 선택",
|
||
postgresClientKeyBrowse: "클라이언트 개인 키 선택",
|
||
connectionUrlOptional: "URL (선택)",
|
||
connectionUrlPlaceholder: "postgresql://user:pass{'@'}host:5432/db?sslmode=require",
|
||
parseConnectionUrl: "연결 URL 파싱",
|
||
parseConnectionUrlApplied: "연결 URL을 적용했습니다",
|
||
parseConnectionUrlFailed: "연결 URL 파싱 실패: {message}",
|
||
mode: "연결 모드",
|
||
modeForm: "양식",
|
||
redisStandaloneMode: "단일",
|
||
redisSentinelMode: "센티널",
|
||
redisClusterMode: "클러스터",
|
||
oceanbaseMySQLMode: "MySQL 모드",
|
||
oceanbaseOracleMode: "Oracle 모드",
|
||
redisFirstSentinel: "첫 번째 센티널",
|
||
redisFirstClusterNode: "첫 번째 시드 노드",
|
||
redisSentinelNodes: "센티널 노드",
|
||
redisClusterNodes: "클러스터 시드 노드",
|
||
redisSentinelMaster: "마스터 이름",
|
||
redisSentinelUser: "센티널 사용자",
|
||
redisSentinelPassword: "센티널 비밀번호",
|
||
redisSentinelTls: "센티널 TLS",
|
||
redisSentinelTlsHint: "센티널 노드에 연결할 때 TLS 사용",
|
||
redisKeySeparator: "키 네임스페이스 구분자",
|
||
redisKeyTemplates: "키 검색 템플릿",
|
||
redisKeyTemplatesPlaceholder: "Example:\nuser:{'{'}$userId{'}'}\nv3:adui:{'{'}$positionID{'}'}",
|
||
redisKeyTemplatesHint: "한 줄에 하나의 템플릿. 설정하면 이 연결의 전역 템플릿을 덮어씁니다.",
|
||
etcdEndpoints: "엔드포인트",
|
||
etcdEndpointsHint: "한 줄에 하나의 엔드포인트. 비워두면 위의 호스트와 포트를 사용합니다.",
|
||
etcdV2ApiHint: "v2 API는 etcd 2.x 또는 --enable-v2로 시작한 etcd 3.0–3.5에서만 사용할 수 있습니다. 키 히스토리, 리스, 컨팩션, 조각모음은 지원되지 않습니다.",
|
||
etcdGrpcMaxInbound: "gRPC 수신 제한 (MiB)",
|
||
etcdGrpcMaxInboundHint: "단일 etcd 응답의 최대 크기입니다. 기본값은 32 MiB이며 최대 256 MiB입니다.",
|
||
etcdCaCertPlaceholder: "/path/to/ca.crt",
|
||
etcdCaCertBrowse: "CA 인증서 선택",
|
||
etcdClientAuth: "클라이언트 인증",
|
||
etcdClientCertPlaceholder: "/path/to/client.crt",
|
||
etcdClientKeyPlaceholder: "/path/to/client.key",
|
||
etcdClientCertHint: "etcd가 mTLS를 요구할 때 클라이언트 인증서와 개인 키를 함께 제공해야 합니다.",
|
||
clientCertHint: "mTLS가 요구되는 경우 클라이언트 인증서와 개인 키를 함께 입력해야 합니다.",
|
||
etcdClientCertBrowse: "클라이언트 인증서 선택",
|
||
etcdClientKeyBrowse: "클라이언트 개인 키 선택",
|
||
etcdClientCertPairRequired: "클라이언트 인증서와 개인 키를 함께 제공해야 합니다.",
|
||
consulAddress: "Consul API 주소",
|
||
consulAddressInvalid: "자격 증명, 쿼리 매개변수 또는 프래그먼트가 없는 HTTP 또는 HTTPS Consul API 절대 주소를 입력하세요.",
|
||
consulToken: "ACL 토큰",
|
||
consulTokenPlaceholder: "Consul ACL 토큰 (선택 사항)",
|
||
consulDatacenter: "데이터센터",
|
||
consulNamespace: "네임스페이스",
|
||
consulPartition: "관리 파티션",
|
||
consulAgentTargetNode: "대상 에이전트 노드",
|
||
consulAgentTargetAddress: "에이전트 직접 연결 주소",
|
||
consulAgentTargetHint: "에이전트 쓰기에 필요합니다. DNS, 로드 밸런싱 및 전송 계층 엔드포인트는 읽기 전용으로 유지됩니다.",
|
||
consulMeshFeatures: "서비스 메시",
|
||
consulMeshVisible: "고급 서비스 메시 작업 영역 표시",
|
||
consulMeshVisibleHint: "Connect, 통신 의도 또는 피어링을 관리할 때만 활성화하세요. 비활성화하면 작업 영역이 숨겨집니다.",
|
||
consulOperatorWrites: "운영 관리 쓰기",
|
||
consulOperatorVisible: "실험적 운영 관리 작업 영역 표시",
|
||
consulOperatorSnapshotRestore: "스냅샷 복원 활성화",
|
||
consulOperatorAutopilot: "Autopilot 업데이트 활성화",
|
||
consulOperatorRaft: "Raft 변경 활성화",
|
||
consulOperatorKeyring: "키링 변경 활성화",
|
||
consulOperatorLicense: "라이선스 업데이트 활성화",
|
||
consulAgentTargetIncomplete: "대상 에이전트 노드와 직접 연결 주소를 함께 설정해야 합니다.",
|
||
consulAgentTargetAddressMismatch: "에이전트 직접 연결 주소는 Consul 엔드포인트 호스트와 일치해야 합니다.",
|
||
consulConsistency: "읽기 일관성",
|
||
consulConsistencyDefault: "기본값",
|
||
consulConsistencyStale: "오래된 읽기 허용 (Stale)",
|
||
consulConsistencyConsistent: "일관된 읽기 (Consistent)",
|
||
consulTlsSkipVerify: "인증서 검증 건너뛰기",
|
||
consulTlsSkipVerifyHint: "신뢰할 수 있는 자체 서명 Consul 엔드포인트에만 사용하세요.",
|
||
zookeeperConnectString: "연결 문자열",
|
||
zookeeperConnectStringHint: "쉼표 또는 줄바꿈으로 구분된 host:port 항목. 비워두면 위의 호스트와 포트를 사용합니다.",
|
||
zookeeperCreateModePersistent: "영구",
|
||
zookeeperCreateModeEphemeral: "임시",
|
||
zookeeperCreateModePersistentSequential: "영구 순차",
|
||
zookeeperCreateModeEphemeralSequential: "임시 순차",
|
||
nacosConsoleUrl: "Nacos 관리 주소",
|
||
nacosConsoleUrlHint: "선택한 Nacos 프로필과 일치하는 주소를 사용하세요. 전체 브라우저와 API URL이 모두 허용됩니다.",
|
||
nacosConsoleUrlRequired: "Nacos 관리 주소는 필수입니다",
|
||
nacosConsoleUrlAutoAdjusted: "Nacos 콘솔 URL을 {from}에서 {to}(으)로 조정했습니다.",
|
||
nacosWebConsoleUrl: "Nacos 웹 콘솔 URL",
|
||
nacosWebConsoleUrlHint: "선택 사항입니다. 브라우저에서 Nacos 콘솔을 엽니다. Nacos 3에는 별도의 웹 콘솔 주소가 필요합니다. 브라우저에서 직접 접근할 수 있어야 하며 DBX 터널이나 API 인증은 재사용되지 않습니다.",
|
||
nacosWebConsoleUrlInvalid: "Nacos 웹 콘솔 URL은 포함된 자격 증명이 없는 유효한 HTTP 또는 HTTPS URL이어야 합니다.",
|
||
nacosRNacosOpenApiAutoAdjusted: "r-nacos OpenAPI로 전환했습니다: {from} → {to} (컨텍스트 경로: /nacos).",
|
||
nacosImplementation: "서비스 구현",
|
||
nacosVersion: "Nacos 버전",
|
||
nacosVersionAuto: "자동 감지",
|
||
nacosPrimaryAddressRNacos: "Nacos 호환 API 주소",
|
||
nacosPrimaryAddressV2: "서비스 주소 (API와 콘솔 공유)",
|
||
nacosPrimaryAddressV3: "서버 / 관리 API 주소",
|
||
nacosPrimaryAddressAuto: "Nacos 관리 주소",
|
||
nacosPrimaryAddressHint: "Nacos 3의 경우 포트 8080 콘솔이 아닌 서버/관리 API 주소(일반적으로 http://host:8848/nacos)를 사용하세요. 사용자 지정 프록시 접두사는 보존됩니다.",
|
||
nacosRequestsUse: "요청은 {address}/…를 사용합니다",
|
||
nacosNamespace: "네임스페이스",
|
||
nacosContextPath: "컨텍스트 경로",
|
||
nacosContextPathPlaceholder: "비워두거나 /nacos",
|
||
nacosContextPathRestoreAuto: "자동으로 복원",
|
||
nacosConfigurationHistory: "구성 기록",
|
||
nacosConfigurationHistoryEnable: "구성 기록 활성화",
|
||
nacosConfigurationHistoryHint:
|
||
"r-nacos 구성 기록은 독립 콘솔(일반적으로 포트 10848)을 통해서만 사용할 수 있습니다. 콘솔은 Nacos 호환 OpenAPI와 별도의 로그인 세션을 가집니다. OpenAPI는 인증이 필요하지 않을 수 있지만 콘솔은 여전히 필요로 합니다. 의도적으로 다른 계정이 필요하지 않은 한 동일한 r-nacos 사용자 계정을 사용하세요.",
|
||
nacosRNacosConsoleUrl: "r-nacos 콘솔 URL",
|
||
nacosRNacosConsoleUrlPlaceholder: "http://127.0.0.1:10848",
|
||
nacosRNacosConsoleUrlHint: "선택. OpenAPI URL이 아닌 독립 콘솔 URL(일반적으로 포트 10848)을 사용하며 구성 기록을 활성화하고 r-nacos 구성 타입과 설명을 읽습니다.",
|
||
nacosRNacosOpenApiRequired: "r-nacos 기본 주소는 독립 콘솔 URL이 아닌 Nacos 호환 API를 사용해야 합니다.",
|
||
nacosRNacosConsoleUrlRequired: "r-nacos 구성 기록에는 콘솔 URL이 필요합니다.",
|
||
nacosConsoleAuthSeparateRequired: "기본 인증이 없음이므로 별도의 콘솔 자격 증명을 구성하세요.",
|
||
nacosAuth: "인증",
|
||
nacosAuthNone: "없음",
|
||
nacosAuthUserPassword: "사용자 / 비밀번호",
|
||
nacosConsoleAuthentication: "콘솔 인증",
|
||
nacosConsoleAuthInherit: "기본 자격 증명 사용",
|
||
nacosConsoleAuthSeparate: "별도 자격 증명",
|
||
nacosConsoleAuthPrimaryNone: "기본 인증이 없음이므로 별도의 콘솔 자격 증명을 사용하세요.",
|
||
nacosConsoleUser: "콘솔 사용자",
|
||
nacosConsolePassword: "콘솔 비밀번호",
|
||
nacosConsoleUsernameRequired: "r-nacos 콘솔 사용자 이름은 필수입니다",
|
||
nacosUsernameRequired: "Nacos 사용자 이름은 필수입니다",
|
||
nacosTls: "TLS",
|
||
nacosTlsSkipVerify: "인증서 검증 건너뛰기",
|
||
nacosPageSize: "페이지 크기",
|
||
nacosMetrics: "Prometheus 메트릭",
|
||
nacosMetricsAuto: "자동 감지",
|
||
nacosMetricsDisabled: "비활성화",
|
||
nacosMetricsCustom: "사용자 지정 URL",
|
||
nacosMetricsAutoHint: "순서대로 시도: {addresses}",
|
||
nacosMetricsUrl: "메트릭 URL",
|
||
nacosMetricsUrlInvalid: "자격 증명이나 프래그먼트 없이 절대 HTTP 또는 HTTPS Prometheus 메트릭 URL을 입력하세요.",
|
||
kafkaKerberosPrincipal: "프린시펄",
|
||
kafkaKerberosKeytab: "Keytab",
|
||
kafkaKerberosServiceName: "서비스 이름",
|
||
kafkaKerberosKrb5Conf: "krb5.conf",
|
||
kafkaKerberosPrincipalRequired: "Kafka Kerberos 프린시펄은 필수입니다",
|
||
kafkaKerberosKeytabRequired: "Kafka Kerberos keytab 경로는 필수입니다",
|
||
kafkaKerberosKeytabBrowse: "Keytab 선택",
|
||
kafkaKerberosKrb5ConfBrowse: "krb5.conf 선택",
|
||
kafkaKerberosKeytabPlaceholder: "DBX Agent 머신의 경로, 예: /etc/security/keytabs/user.keytab",
|
||
kafkaKerberosKrb5ConfPlaceholder: "DBX Agent 머신의 선택 경로, 예: /etc/krb5.conf",
|
||
kafkaKerberosPathHint: "keytab과 krb5.conf 경로는 DBX Agent가 읽으며 DBX Agent를 실행하는 머신에 존재해야 합니다. 이 브라우저에서 파일이 업로드되지 않습니다.",
|
||
kafkaKerberosAuthHint: "GSSAPI + keytab 로그인을 사용합니다. 서버가 암호화 전송을 요구하면 보안을 SASL_SSL로 설정하고, 그렇지 않으면 자동 또는 SASL_PLAINTEXT를 사용할 수 있습니다.",
|
||
mqSystem: "시스템",
|
||
mqSystemPulsar: "Apache Pulsar",
|
||
mqSystemKafka: "Apache Kafka",
|
||
mqSystemRocketMq: "Apache RocketMQ",
|
||
rocketmqNamesrvAddr: "NameServer 주소",
|
||
rocketmqNamesrvAddrPlaceholder: "127.0.0.1:9876",
|
||
rocketmqNamesrvAddrRequired: "RocketMQ NameServer 주소는 필수입니다",
|
||
rocketmqNamesrvAddrInvalid: "RocketMQ NameServer 주소가 잘못되었습니다",
|
||
rocketmqClusterName: "클러스터 이름",
|
||
rocketmqClusterNamePlaceholder: "선택, 예: DefaultCluster",
|
||
rocketmqAccessKey: "Access Key",
|
||
rocketmqSecretKey: "Secret Key",
|
||
rocketmqAclAuth: "ACL",
|
||
mqBootstrapServers: "부트스트랩 서버",
|
||
mqBootstrapServersPlaceholder: "127.0.0.1:9092",
|
||
mqBootstrapServersRequired: "Kafka 부트스트랩 서버는 필수입니다",
|
||
mqBootstrapServersInvalid: "Kafka 부트스트랩 서버가 잘못되었습니다",
|
||
mqKafkaConnectionSource: "연결 소스",
|
||
mqKafkaConnectionSourceBootstrap: "부트스트랩 서버",
|
||
mqKafkaConnectionSourceZooKeeper: "ZooKeeper (Kafka 1.x)",
|
||
mqKafkaZooKeeperServers: "ZooKeeper 서버",
|
||
mqKafkaZooKeeperServersPlaceholder: "zk1:2181,zk2:2181/kafka",
|
||
mqSystemRabbitMq: "RabbitMQ",
|
||
mqRabbitmqAddresses: "주소",
|
||
mqRabbitmqAddressesPlaceholder: "127.0.0.1:5672",
|
||
mqRabbitmqAddressesRequired: "RabbitMQ 주소는 필수입니다",
|
||
mqRabbitmqAddressesInvalid: "RabbitMQ 주소를 host:port 형식(예: 127.0.0.1:5672)으로 입력하고 amqp://는 포함하지 마세요",
|
||
mqVirtualHost: "가상 호스트",
|
||
mqVirtualHostPlaceholder: "/",
|
||
mqRabbitmqAdminUrl: "관리 URL",
|
||
mqRabbitmqAdminUrlPlaceholder: "http://192.168.1.1:15672",
|
||
mqRabbitmqAdminUrlHint: "기본 AMQP 포트에서만 비워 둘 수 있습니다. 사용자 지정 AMQP 포트는 별도로 구성된 Management API URL이 필요합니다. https://proxy/rmq 같은 역방향 프록시 경로도 지원합니다",
|
||
mqRabbitmqUsernamePlaceholder: "기본값 guest",
|
||
mqRabbitmqPasswordPlaceholder: "기본값 guest",
|
||
mqSecurity: "보안",
|
||
mqSecurityAuto: "자동",
|
||
mqAdminUrl: "관리 URL",
|
||
mqAdminUrlRequired: "MQ 관리 URL은 필수입니다",
|
||
mqAdminUrlInvalid: "MQ 관리 URL이 잘못되었습니다",
|
||
mqAuth: "인증",
|
||
mqAuthNone: "없음",
|
||
mqAuthToken: "토큰",
|
||
mqAuthBasic: "Basic",
|
||
mqAuthKerberos: "Kerberos",
|
||
mqAuthApiKey: "API 키",
|
||
mqAuthOauth2: "OAuth2",
|
||
mqToken: "토큰",
|
||
mqSaslMechanism: "SASL 메커니즘",
|
||
mqApiKeyHeader: "헤더",
|
||
mqApiKeyValue: "값",
|
||
mqOauthIssuerUrl: "발급자 URL",
|
||
mqOauthClientId: "클라이언트 ID",
|
||
mqOauthClientSecret: "클라이언트 시크릿",
|
||
mqOauthAudience: "대상",
|
||
mqOauthScope: "범위",
|
||
mqOauthIssuerRequired: "OAuth2 인증에는 발급자 URL이 필요합니다",
|
||
mqOauthClientIdRequired: "OAuth2 인증에는 클라이언트 ID가 필요합니다",
|
||
mqOauthClientSecretRequired: "OAuth2 인증에는 클라이언트 시크릿이 필요합니다",
|
||
mqTls: "TLS",
|
||
mqTlsSkipVerify: "인증서 검증 건너뛰기",
|
||
mqPinnedVersion: "고정 버전",
|
||
mqTokenSigning: "브로커 토큰 서명",
|
||
mqTokenSigningNone: "구성되지 않음",
|
||
mqTokenSigningKey: "서명 키",
|
||
mqTokenSigningKeyRequired: "브로커 토큰 서명 키는 필수입니다",
|
||
mqTokenSigningKeyPlaceholderHs256: "브로커 SECRET",
|
||
mqTokenSigningKeyPlaceholderRs256: "-----BEGIN PRIVATE KEY-----",
|
||
mqTokenSigningHint: "브로커 jwt.broker.token.mode에 따라 선택하세요: SECRET은 HS256, PRIVATE은 RS256을 사용합니다. 키는 연결 비밀과 함께 저장됩니다.",
|
||
searchDatabasePlaceholder: "데이터베이스 유형 검색",
|
||
searchResults: "검색 결과",
|
||
databaseCategories: "카테고리",
|
||
databaseCategorySql: "관계형",
|
||
databaseCategoryAnalytics: "분석형",
|
||
databaseCategoryDomestic: "중국 DB",
|
||
databaseCategoryLightweight: "경량",
|
||
databaseCategoryDocument: "문서/캐시/검색",
|
||
databaseCategoryGraphAi: "그래프/벡터",
|
||
databaseCategoryTimeseries: "시계열",
|
||
databaseCategoryMq: "메시지 큐",
|
||
databaseCategoryRegistryConfig: "레지스트리/구성",
|
||
jdbcConnection: "JDBC 연결",
|
||
iconView: "아이콘 보기",
|
||
listView: "목록 보기",
|
||
selectedDatabase: "선택됨",
|
||
noDatabaseMatches: "일치하는 데이터베이스가 없습니다",
|
||
next: "다음",
|
||
back: "이전",
|
||
basicTab: "연결",
|
||
tlsTab: "TLS/SSL",
|
||
test: "테스트",
|
||
testing: "테스트 중...",
|
||
copyTestResult: "테스트 결과 복사",
|
||
sqlServerLegacyCompatibilityMode: "레거시 호환 모드",
|
||
sqlServerLegacyCompatibilityModeEnable: "활성화",
|
||
sqlServerLegacyCompatibilityModeHint: "TLS 1.0, 로그인 전용 암호화 또는 암호화 없이 제한되는 SQL Server 인스턴스용.\n일부 기능이 제한될 수 있으며 신뢰할 수 있는 네트워크에서만 사용하세요.",
|
||
sqlServerLegacyCompatibilityComponent: "SQL Server 레거시 호환 구성 요소",
|
||
gaussdbConnectionMode: "연결 모드",
|
||
gaussdbConnectionModeNative: "PostgreSQL 호환(내장 드라이버)",
|
||
gaussdbConnectionModeMJdbc: "M 모드(공급업체 JDBC 드라이버)",
|
||
gaussdbConnectionModeNativeHint: "GaussDB A/PG/Oracle 호환 모드에서는 DBX 내장 PostgreSQL 호환 프로토콜을 사용합니다.",
|
||
gaussdbConnectionModeMJdbcHint: "GaussDB M 모드에서는 jdbc:gaussdb와 com.huawei.gaussdb.jdbc.Driver를 사용합니다.",
|
||
gaussdbMJdbcDriver: "GaussDB JDBC 드라이버",
|
||
gaussdbMJdbcDriverPlaceholder: "서버 버전에 맞는 gaussdbjdbc.jar 선택",
|
||
gaussdbMJdbcDriverHint: "드라이버는 각 GaussDB 서버 버전과 함께 배포됩니다. 해당 GaussDB 드라이버 패키지에서 gaussdbjdbc.jar를 가져오세요.",
|
||
gaussdbMJdbcDriverRequired: "GaussDB M 모드에는 공급업체 JDBC 드라이버가 필요합니다. 서버 버전에 맞는 gaussdbjdbc.jar를 선택하세요.",
|
||
gaussdbMJdbcPluginInstalling: "JDBC 런타임 설치 중...",
|
||
gaussdbTargetServerType: "대상 서버 유형",
|
||
gaussdbTargetServerTypeMaster: "마스터(기본)",
|
||
gaussdbTargetServerTypeSlave: "슬레이브(대기)",
|
||
gaussdbTargetServerTypeAny: "임의(선호 없음)",
|
||
gaussdbTargetServerTypeHint: "JDBC 드라이버가 연결할 GaussDB 클러스터 노드를 제어합니다. M 모드(JDBC)에만 적용됩니다.",
|
||
gaussdbCountQueryDop: "COUNT(*) 병렬 처리 수준",
|
||
gaussdbCountQueryDopHint: "대형 테이블의 COUNT(*) 쿼리에 query_dop(병렬 처리 수준)를 설정합니다. 값이 클수록 더 많은 리소스를 사용합니다. 옵티마이저 힌트를 비활성화하려면 1(기본값)로 설정하세요.",
|
||
saveAndConnect: "저장 후 연결",
|
||
save: "저장",
|
||
editTitle: "연결 편집",
|
||
testSuccess: "연결 성공",
|
||
databaseInfo: {
|
||
title: "데이터베이스 정보",
|
||
open: "{database}의 데이터베이스 정보 열기",
|
||
copy: "데이터베이스 정보 복사",
|
||
sourceConfigured: "현재 구성",
|
||
sourceTested: "테스트됨",
|
||
configuredDescription: "먼저 양식에서 알려진 정보를 표시합니다. 성공적인 테스트는 서버 버전과 드라이버 메타데이터를 추가합니다.",
|
||
testedDescription: "이 정보는 가장 최근 성공한 테스트에 사용된 연결에서 가져왔습니다.",
|
||
productName: "DBMS",
|
||
productVersion: "서버 버전",
|
||
currentDatabase: "현재 데이터베이스",
|
||
serverComment: "서버 주석",
|
||
serverCharset: "서버 문자셋",
|
||
serverCollation: "서버 정렬",
|
||
unquotedIdentifierCase: "따옴표 없는 식별자",
|
||
quotedIdentifierCase: "따옴표 있는 식별자",
|
||
driverName: "드라이버",
|
||
driverVersion: "드라이버 버전",
|
||
jdbcVersion: "JDBC 버전",
|
||
identifierCase: {
|
||
lower: "소문자",
|
||
upper: "대문자",
|
||
mixed: "혼합 대소문자",
|
||
},
|
||
},
|
||
connecting: "{name}에 연결하는 중...",
|
||
connectSuccess: "{name}에 연결됨",
|
||
connectFailed: "연결 실패: {message}",
|
||
driverNotInstalled: "{driver} 드라이버가 설치되지 않았습니다. 드라이버 관리자에서 설치하세요.",
|
||
phoenixDriverNotInstalled: "Apache Phoenix JDBC 드라이버가 설치되지 않았습니다. 드라이버 관리자에서 설치한 후 다시 시도하세요.",
|
||
jreNotInstalled: "JRE {jre} 런타임이 설치되지 않았습니다. 드라이버 관리자에서 설치하세요.",
|
||
systemJavaNotFound: "PATH에서 시스템 Java 런타임을 찾을 수 없습니다. Java를 설치하거나 사용자 지정 Java 실행 파일을 선택하세요.",
|
||
customJavaPathEmpty: "사용자 지정 Java 런타임 경로가 비어 있습니다. Java 실행 파일을 선택하세요.",
|
||
agentJavaTooOld: "이 드라이버는 Java 21이 필요합니다. DBX 관리 JRE 21을 사용하거나 드라이버 관리자에서 Java 21 실행 파일을 선택하세요.",
|
||
agentDriverUpdateConnectionHint: "이 연결에 사용 가능한 내장 드라이버 업데이트가 있습니다. 연결 실패가 오래된 로컬 드라이버와 관련이 있을 수 있습니다. 드라이버 관리자에서 해당 드라이버를 업데이트한 후 다시 시도하세요.",
|
||
jdbcPluginNotInstalled: "JDBC 플러그인이 설치되지 않았습니다. 이 연결을 사용하려면 선택적 JDBC 플러그인을 설치하세요.",
|
||
connectFailedTitle: "연결 실패",
|
||
fullErrorMessage: "전체 오류 메시지",
|
||
copyError: "오류 복사",
|
||
optionalSuffix: " (선택)",
|
||
customColorPlaceholder: "#ff0000 또는 rgba(…)",
|
||
tursoHostPlaceholder: "your-database.turso.io 또는 libsql://your-database.turso.io",
|
||
tursoHostHint: "libsql:// 및 https:// 프로토콜을 지원합니다. 호스트 이름만 입력해도 됩니다 (HTTPS가 자동으로 사용됨).",
|
||
tursoTokenHint: "다음으로 토큰을 만드세요:",
|
||
tursoUrlParamsPlaceholder: "authToken=xxx (선택, 위의 인증 토큰 필드가 우선)",
|
||
driverInstall: {
|
||
installingTitle: "드라이버 설치 중",
|
||
failedTitle: "드라이버 설치 실패",
|
||
fullError: "전체 오류",
|
||
statusFailed: "설치 실패",
|
||
statusWaiting: "설치 대기 중",
|
||
statusPreparing: "드라이버 설치 준비 중...",
|
||
statusExtractingJre: "JRE 압축 푸는 중...",
|
||
stepJre: "JRE 다운로드",
|
||
stepDriver: "드라이버 다운로드",
|
||
stepDefault: "드라이버 설치",
|
||
installingButton: "설치 중...",
|
||
},
|
||
lastError: "연결 오류",
|
||
errorIndicatorHint: "연결 오류. 클릭하여 상세 보기",
|
||
clearError: "연결 오류 지우기",
|
||
saveFailed: "연결 저장 실패: {message}",
|
||
savedSettingsFailed: "연결은 저장되었지만 표시 설정을 저장하지 못했습니다: {message}. 설정을 저장하려면 다시 시도하세요.",
|
||
deleted: "연결을 삭제했습니다",
|
||
deletedSelected: "연결 {count}개 삭제",
|
||
copied: "복사했습니다",
|
||
disconnected: "연결이 끊겼습니다",
|
||
disconnectedSelected: "연결 {count}개를 끊었습니다",
|
||
disconnectSelectedPartial: "연결 {succeeded}개를 끊었고 {failed}개는 실패했습니다",
|
||
databaseConnectionClosed: "데이터베이스 연결 닫음: {name}",
|
||
duplicated: "연결을 복제했습니다",
|
||
duplicatedSelected: "연결 {count}개 복제",
|
||
groupDeleted: "그룹을 삭제했습니다",
|
||
groupsDeleted: "그룹 {count}개를 삭제했습니다",
|
||
loadFailed: "저장된 연결을 불러오는 데 실패했습니다: {message}",
|
||
sshTunnel: "터널 / 프록시",
|
||
sshTunnelTest: "SSH 터널 테스트",
|
||
sshTunnelTesting: "SSH 터널 테스트 중...",
|
||
sshTunnelTestSuccess: "SSH 터널 연결 성공",
|
||
advancedTab: "고급",
|
||
sshEnable: "터널 / 프록시 사용",
|
||
sshHost: "SSH 호스트",
|
||
sshHostPlaceholder: "ssh.example.com 또는 ~/.ssh/config의 별칭",
|
||
sshUser: "SSH 사용자",
|
||
sshAuthMethod: "로그인 방법",
|
||
sshAuthMethodPassword: "비밀번호",
|
||
sshAuthMethodKey: "개인 키",
|
||
sshAuthMethodKeyPassword: "개인 키 + 비밀번호",
|
||
sshAuthMethodNone: "없음",
|
||
sshAuthMethodNoneHint: "자격 증명이 전송되지 않습니다. 인증되지 않은 연결을 허용하는 배스천이나 프록시에 사용하세요.",
|
||
sshAuthMethodAgentLegacy: "SSH 에이전트 (레거시)",
|
||
sshPassword: "SSH 비밀번호",
|
||
sshPasswordPlaceholder: "키를 사용하려면 비워 두세요",
|
||
sshKeyPath: "키 경로",
|
||
sshKeyPassphrase: "키 암호",
|
||
sshKeyPassphrasePlaceholder: "키가 암호화되지 않은 경우 비워 두세요",
|
||
sshKeyPathBrowse: "찾아보기",
|
||
sshExposeLan: "터널을 LAN에 노출",
|
||
sshAllowExecChannelProxy: "SSH exec 채널 대체(nc) 활성화",
|
||
sshConnectTimeout: "SSH 제한 시간 (초)",
|
||
sshHops: "터널 / 프록시 계층",
|
||
sshHopAdd: "SSH 계층 추가",
|
||
sshHopDuplicate: "복제",
|
||
sshHopDelete: "삭제",
|
||
sshHopMoveUp: "위로 이동",
|
||
sshHopMoveDown: "아래로 이동",
|
||
sshHopName: "계층 이름",
|
||
sshHopNamePlaceholder: "배스천, 점프 호스트, 프로덕션 게이트웨이",
|
||
sshHopDefaultName: "계층 {index}",
|
||
sshHopInvalidHost: "{hop}: SSH 호스트는 필수입니다",
|
||
sshHopInvalidUser: "{hop}: SSH 사용자는 필수입니다",
|
||
sshHopInvalidPort: "{hop}: SSH 포트는 1에서 65535 사이여야 합니다",
|
||
sshHopInvalidAuth: "{hop}: 비밀번호, 키 경로 또는 ssh-agent가 필요합니다",
|
||
sshUseAgent: "ssh-agent 사용",
|
||
sshAgentSockPath: "에이전트 소켓 경로",
|
||
sshAgentSockPathPlaceholder: "예: ~/.ssh/agent.sock",
|
||
sshHostKeyVerifyTitle: "알 수 없는 SSH 호스트 키 확인",
|
||
sshHostKeyVerifyMessage: "'{host}:{port}'의 신뢰성을 확인할 수 없습니다. 중간자 공격으로부터 보호하기 위해 계속하기 전에 서버 관리자와 함께 호스트 키 지문을 검증하세요.",
|
||
sshHostKeyVerifyKeyType: "키 유형",
|
||
sshHostKeyVerifyFingerprint: "지문",
|
||
sshHostKeyVerifyRemember: "이 호스트 신뢰 (향후 연결을 위해 이 키 기억)",
|
||
sshHostKeyVerifyAccept: "수락 후 연결",
|
||
sshHostKeyVerifyReject: "취소",
|
||
sshHostKeyChangedTitle: "호스트 지문이 변경되었습니다",
|
||
sshHostKeyChangedMessage: "{host}의 저장된 지문이 현재 서버와 일치하지 않습니다.",
|
||
sshHostKeyChangedCurrent: "{keyType} 지문(SHA256):",
|
||
sshHostKeyChangedSaved: "저장된 지문",
|
||
sshHostKeyChangedWarning: "이 호스트가 실제로 변경되었음을 확신하는 경우에만 계속하세요.",
|
||
sshHostKeyChangedClose: "닫기",
|
||
sshHostKeyChangedContinue: "계속",
|
||
sshHostKeyChangedUpdate: "업데이트 후 계속",
|
||
sshInteractiveTitle: "SSH 인증 필요",
|
||
sshInteractiveMessage: "SSH 서버 {host}:{port}에서 추가 인증을 요구합니다.",
|
||
sshInteractiveDefaultPrompt: "서버에서 요청한 인증 정보를 입력하세요.",
|
||
sshInteractivePlaceholder: "인증 코드 입력",
|
||
sshInteractiveSubmit: "인증",
|
||
sshInteractiveCancel: "취소",
|
||
sshHostKeyNoticeChanged: "{host}:{port}의 호스트 키가 변경되었습니다 — 이는 중간자 공격을 나타낼 수 있습니다. 이 변경을 예상한 경우에만 이전 항목을 제거하고 다시 연결하세요.",
|
||
sshHostKeyNoticeRejected: "{host}:{port}의 호스트 키를 거부했습니다. 연결이 중단되고 자격 증명이 전송되지 않았습니다.",
|
||
sshHostKeyNoticeLearnFailed: "{host}:{port}의 호스트 키를 저장할 수 없습니다 — 이 호스트는 이 세션에만 신뢰되며 다음에 다시 확인을 요청받습니다.",
|
||
sshHostKeyNoticeGeneric: "{host}:{port}의 SSH 호스트 키 검증에 실패했습니다.",
|
||
sqliteTransportSshOnly: "원격 SQLite는 SSH 홉만 지원합니다. 프록시 및 HTTP 터널 계층은 사용할 수 없습니다.",
|
||
sqliteRemotePathPlaceholder: "/var/lib/app/data.db",
|
||
sqliteRemotePathHint: "마지막 SSH 홉의 절대 경로를 입력하세요.",
|
||
sqliteSshCipherUnsupportedHint: "SSH를 통한 암호화(SQLCipher)된 SQLite 데이터베이스 연결은 아직 지원되지 않습니다.",
|
||
sqliteWorkerPlacement: "SQLite 워커",
|
||
sqliteWorkerPlacementSession: "세션",
|
||
sqliteWorkerPlacementPersist: "영속",
|
||
sqliteWorkerPlacementPreplaced: "사전 배치",
|
||
sqliteWorkerPlacementSessionHint: "DBX가 SSH를 통해 워커를 파일 호스트에 업로드하고 연결을 끊으면 원격 파일을 삭제합니다. 일시적인 사용에 적합합니다.",
|
||
sqliteWorkerPlacementPersistHint: "DBX가 SSH를 통해 워커를 파일 호스트에 업로드하고 연결을 끊은 후에도 그대로 둡니다. 자동으로 삭제되지 않습니다.",
|
||
sqliteWorkerPlacementPreplacedHint: "워커를 직접 파일 호스트에 업로드한 후 해당 절대 경로를 입력하세요. DBX가 자동으로 업로드하거나 삭제하지는 않지만, 파일이 현재 Desktop 버전과 일치하는지 검증합니다.",
|
||
sqliteWorkerPlacementDefault: "기본값",
|
||
sqliteWorkerPersistPathPlaceholder: "~/.cache/dbx/sqlite-worker/<digest>",
|
||
sqliteWorkerPreplacedPathPlaceholder: "/opt/dbx/dbx-sqlite-worker",
|
||
sshWorkerUploadConsentTitle: "SQLite 워커 업로드",
|
||
sshWorkerUploadConsentMessage: "DBX가 수명이 짧은 SQLite 워커를 {host}:{port}에 복사해야 합니다. 이것은 권한이 필요한 작업입니다. 업로드를 허용하기 전에 대상 경로와 다이제스트를 확인하세요.",
|
||
sshWorkerUploadConsentPath: "대상 경로",
|
||
sshWorkerUploadConsentDigest: "워커 다이제스트",
|
||
sshWorkerUploadConsentRemember: "이 파일 호스트와 다이제스트 기억",
|
||
sshWorkerUploadConsentAccept: "업로드",
|
||
sshWorkerUploadConsentReject: "취소",
|
||
sshHopInvalidTimeout: "{hop}: SSH 제한 시간은 1에서 300초 사이여야 합니다",
|
||
connectTimeout: "연결 제한 시간 (초)",
|
||
queryTimeout: "쿼리 제한 시간 (초)",
|
||
useGlobalQueryTimeout: "전역",
|
||
globalConnectTimeoutHint: "범위: 1~300초",
|
||
globalQueryTimeoutHint: "범위: 0~3600초. 0으로 설정하면 제한이 없습니다.",
|
||
useConnectionQueryTimeout: "연결",
|
||
idleTimeout: "유휴 제한 시간 (초)",
|
||
keepaliveInterval: "킵얼라이브 간격 (초)",
|
||
readOnly: "읽기 전용",
|
||
readOnlyHint: "모든 쓰기 작업 차단 (INSERT, UPDATE, DELETE 등)",
|
||
showSystemSchemas: "시스템 스키마 표시",
|
||
showSystemSchemasHint: "이 연결의 사이드바와 스키마 선택기에 내장 및 메타데이터 스키마를 표시합니다.",
|
||
docsNotesPath: "노트 파일",
|
||
docsNotesPathPlaceholder: "docs/dbx-docs.json",
|
||
docsNotesPathHint: "문서 노트를 저장할 위치입니다. 비워 두면 앱 데이터 디렉터리에 저장되며, 저장소 내 파일을 지정하면 스키마 문서를 풀 리퀘스트에서 검토할 수 있습니다.",
|
||
readOnlyBadge: "읽기 전용",
|
||
proxy: "프록시",
|
||
proxyEnable: "프록시를 통해 데이터베이스 연결",
|
||
proxyType: "프록시 유형",
|
||
proxyHost: "프록시 호스트",
|
||
proxyUsername: "프록시 사용자",
|
||
proxyUsernamePlaceholder: "선택",
|
||
proxyPassword: "프록시 비밀번호",
|
||
proxyPasswordPlaceholder: "선택",
|
||
proxyTestTarget: "테스트 대상",
|
||
proxyTestTargetPlaceholder: "host:port — 비움 = 엔드포인트 확인, 채우면 전체 터널 테스트",
|
||
tunnelProfile: "터널 프로필",
|
||
tunnelProfileCustom: "사용자 지정 (이 연결만)",
|
||
tunnelProfileManaged: "공유 터널 프로필로 관리됩니다. 설정 > 터널에서 편집하세요 — 변경 사항은 사용하는 모든 연결의 다음 연결에 적용됩니다.",
|
||
tunnelProfileMissing: "참조된 터널 프로필이 더 이상 존재하지 않습니다. 다른 프로필을 선택하거나 사용자 지정으로 전환하세요.",
|
||
tunnelProfileMissingName: "누락된 터널 프로필",
|
||
tunnelProfileManage: "관리",
|
||
httpTunnel: "HTTP 터널",
|
||
httpTunnelAdd: "HTTP 터널 추가",
|
||
httpTunnelUrl: "터널 스크립트 URL",
|
||
httpTunnelToken: "터널 토큰",
|
||
httpTunnelTokenPlaceholder: "dbx_tunnel.php에 구성된 토큰",
|
||
httpTunnelConnectTimeout: "터널 제한 시간 (초)",
|
||
httpTunnelDefaultName: "HTTP 터널 {index}",
|
||
httpTunnelInvalidOrder: "{hop}: HTTP 터널은 첫 번째 터널/프록시 계층이어야 합니다",
|
||
httpTunnelInvalidUrl: "{hop}: 터널 스크립트 URL은 필수입니다",
|
||
httpTunnelInvalidTimeout: "{hop}: HTTP 터널 제한 시간은 1에서 300초 사이여야 합니다",
|
||
dremioArrowFlightSqlMode: "Arrow Flight SQL",
|
||
dremioLegacyJdbcMode: "레거시 JDBC",
|
||
phoenixDirectMode: "직접 연결",
|
||
phoenixRuntimeOption: "Apache Phoenix JDBC({mode})",
|
||
phoenixQueryServerMode: "Query Server",
|
||
phoenixDirectModeHint: "HBase에 직접 연결합니다. 기본 런타임은 Phoenix 5.2.1 및 HBase 2.5를 대상으로 합니다. 다른 클러스터 버전에서는 호환되는 Phoenix 클라이언트를 선택하고 필요한 경우 hbase-site.xml을 추가하세요.",
|
||
phoenixQueryServerModeHint: "Phoenix Thin Client를 사용하여 별도로 배포된 Phoenix Query Server(PQS)에 HTTP로 연결합니다.",
|
||
phoenixDriverManagerHintPrefix: "기본 런타임은 ",
|
||
phoenixDriverManagerHintSuffix: "에서 설치하거나 제거할 수 있습니다. 수동으로 선택한 호환 드라이버 경로가 우선합니다.",
|
||
phoenixDocs: "Phoenix 문서 보기",
|
||
jdbcUrl: "JDBC URL",
|
||
jdbcUrlPlaceholder: "jdbc:postgresql://localhost:5432/database",
|
||
jdbcDriverClass: "드라이버 클래스 (선택)",
|
||
jdbcDriverClassPlaceholder: "대부분의 드라이버는 자동 등록됩니다. 필요하면 com.vendor.jdbc.Driver를 사용하세요",
|
||
jdbcDriverPaths: "드라이버 JAR",
|
||
jdbcDriverSelectPlaceholder: "가져온 드라이버 선택",
|
||
jdbcManualClasspath: "수동 클래스패스",
|
||
jdbcManualClasspathCount: "{count}개 경로",
|
||
jdbcDriverPathsPlaceholder: "/path/to/driver.jar\n/path/to/another-driver.jar",
|
||
jdbcDriverBrowse: "JDBC 드라이버 JAR 선택",
|
||
jdbcDocs: "JDBC 문서 보기",
|
||
jdbcPluginHint: "먼저 DBX JDBC 플러그인을 설치하세요. 외부 종속성이 있는 드라이버의 경우 드라이버 관리자에서 Maven으로 설치하거나 드라이버와 모든 종속성 JAR을 함께 가져오세요.",
|
||
jdbcMissingRuntimeDependencyHint: "이 JDBC 드라이버에 런타임 종속성이 누락되었습니다. 드라이버 관리자에서 Maven으로 설치하거나 드라이버와 모든 종속성 JAR을 함께 가져오세요.",
|
||
jdbcxExtensions: "JDBCX 확장",
|
||
jdbcxHighPrivilegeExtensions: "고권한 확장 허용",
|
||
jdbcxHighPrivilegeExtensionsWarning: "기본적으로 비활성화됩니다. 활성화하면 Shell, Script, Web, MCP 및 기타 확장이 로컬 명령을 실행하거나 네트워크에 접근할 수 있습니다.",
|
||
dmCompatHint: "시스템에 DM8 ODBC 드라이버가 설치되어 있어야 합니다.",
|
||
dmDownload: "Dameng에서 다운로드",
|
||
mongoLegacyHint: "오래된 MongoDB 서버, 특히 4.2 미만 버전에는 레거시를 사용하세요. 인증이 실패하고 사용자가 admin에서 생성된 경우 인증 DB를 admin으로 설정하세요.",
|
||
mongoTlsAllowInvalidCertificates: "TLS 인증서 검증 비활성화",
|
||
mongoTlsAllowInvalidCertificatesHint: "tlsAllowInvalidCertificates=true에 매핑되며 호스트 이름 확인뿐만 아니라 모든 인증서 검증을 비활성화합니다. 이는 MITM 위험을 증가시킵니다. SSH 터널을 통한 AWS DocumentDB에 일반적으로 필요합니다.",
|
||
mongoRetryWrites: "쓰기 재시도",
|
||
mongoRetryWritesHint: "retryWrites에 매핑됩니다. 재시도 가능한 쓰기를 지원하지 않는 AWS DocumentDB의 경우 비활성화하세요.",
|
||
compatible: "호환",
|
||
mainstream: "인기",
|
||
color: "색상",
|
||
colorNone: "색상 없음",
|
||
colorGreen: "초록",
|
||
colorYellow: "노랑",
|
||
colorOrange: "주황",
|
||
colorRed: "빨강",
|
||
colorBlue: "파랑",
|
||
colorPurple: "보라",
|
||
colorCustom: "사용자 지정 색상",
|
||
cancelConnecting: "연결 취소",
|
||
connectCancelled: "연결이 취소되었습니다",
|
||
sshTotpCancelled: "일회용 코드 입력이 취소되었습니다",
|
||
mqttSearchPayloadPlaceholder: "메시지 Payload 검색...",
|
||
mqttNoMatchingMessages: "현재 Payload 필터 조건과 일치하는 로드된 메시지가 없습니다.",
|
||
databaseCategoryPlugins: "플러그인",
|
||
pluginProviderUnavailable: "이 플러그인 연결 제공자를 사용할 수 없습니다. 플러그인을 다시 설치하거나 활성화한 후 다시 시도하세요.",
|
||
pluginRequiredField: "{field}을(를) 입력하세요.",
|
||
pluginSshKeyPickerPlaceholder: "로컬 SSH 키 선택…",
|
||
pluginSshKeyPickerEmpty: "키를 찾을 수 없음",
|
||
pluginSshKeyEncrypted: "암호화됨",
|
||
objectCacheRefreshFailed: "개체 캐시 새로 고침 실패: {message}",
|
||
},
|
||
editor: {
|
||
duckdbDraining: "이전 DuckDB 쿼리가 아직 중지 중입니다. 잠시 후 다시 시도해 주세요.",
|
||
statementExecutionRunning: "{count}개 구문 실행 중",
|
||
statementExecutionSucceeded: "{count}개 구문 성공",
|
||
statementExecutionFailed: "{count}개 구문 실패",
|
||
pressToExecute: "{mod}+Enter를 눌러 실행",
|
||
pressToSaveSql: "{mod}+S를 눌러 SQL 저장",
|
||
queryTimeoutError: "쿼리 시간 초과 ({seconds}초). 데이터베이스 연결이 정상인지 확인하세요.",
|
||
changeConnectionTimeout: "연결 제한 시간 변경",
|
||
changeQueryTimeout: "쿼리 제한 시간 변경",
|
||
locateError: "오류 위치로 이동 ({line}행 {column}열)",
|
||
errorPositionUnavailable: "오류 위치가 현재 편집기 내용과 일치하지 않아 위치를 찾을 수 없습니다.",
|
||
connectionMayBeLost: "연결이 끊어졌을 수 있습니다. 데이터를 새로고침하고 다시 시도하세요.",
|
||
showResultsPane: "결과 표시",
|
||
hideResultsPane: "결과 숨기기",
|
||
noDatabase: "선택한 데이터베이스가 없습니다",
|
||
unsavedChangesTitle: "저장되지 않은 변경 사항",
|
||
unsavedChangesMessage: '"{title}"에 저장되지 않은 변경 사항이 있으며 닫으면 손실됩니다. 닫기 전에 저장하시겠습니까?',
|
||
unsavedChangesBatchCloseMessage: "닫으려는 일부 탭에 저장되지 않은 변경 사항이 있어 손실됩니다. 계속하기 전에 저장하시겠습니까?",
|
||
unsavedChangesBatchCloseMultipleMessage: '닫으려는 SQL 탭 {count}개에 저장되지 않은 변경 사항이 있습니다. DBX는 현재 "{title}"을(를) 표시 중입니다. 계속하기 전에 저장하시겠습니까?',
|
||
unsavedChangesAppCloseMessage: '"{title}"에 저장되지 않은 SQL 변경 사항이 있으며 DBX를 종료하면 손실됩니다. 종료 전에 저장하시겠습니까?',
|
||
unsavedChangesAppCloseMultipleMessage: 'SQL 탭 {count}개에 저장되지 않은 변경 사항이 있습니다. DBX는 현재 "{title}"을(를) 표시 중입니다. 종료 전에 저장하시겠습니까?',
|
||
unsavedChangesViewList: "탭 {count}개 보기",
|
||
unsavedChangesListTitle: "저장되지 않은 탭 ({count})",
|
||
discardChanges: "저장 안 함",
|
||
discardAllChanges: "모두 저장 안 함",
|
||
saveAllChanges: "모두 저장",
|
||
selectConnection: "연결 선택",
|
||
searchConnection: "연결 검색...",
|
||
selectDatabase: "데이터베이스 선택",
|
||
selectDatabaseRequired: "먼저 데이터베이스를 선택하세요",
|
||
searchDatabase: "데이터베이스 검색...",
|
||
selectSchema: "스키마 선택",
|
||
searchSchema: "스키마 검색...",
|
||
setDefaultDatabase: "기본값으로 설정",
|
||
defaultDatabase: "기본",
|
||
defaultSchema: "기본",
|
||
clearDatabase: "데이터베이스 지우기",
|
||
exPasteNoValues: "클립보드에 IN 조건에 사용할 값이 없습니다",
|
||
exPasteNotList: "변환 가능한 다중 값 목록이 감지되지 않았습니다",
|
||
exPasteTooLarge: "클립보드 내용이 너무 큽니다. 지원되는 최대 길이는 {limit}자입니다.",
|
||
exPasteTooManyValues: "값이 너무 많습니다. 지원되는 최대 개수는 {limit}개입니다.",
|
||
exPasteClipboardReadFailed: "클립보드 읽기에 실패했습니다: {message}",
|
||
exPastePasted: "IN 조건 값 {count}개를 붙여넣었습니다",
|
||
completion: {
|
||
nullValue: "NULL 값",
|
||
isNull: "NULL인지 확인",
|
||
isNotNull: "NULL이 아닌지 확인",
|
||
stringLiteral: "문자열 리터럴",
|
||
numericLiteral: "숫자 리터럴",
|
||
booleanValue: "불리언 값",
|
||
starExpansionColumns: "{count}개 컬럼",
|
||
insertSelectedColumns: "선택한 열 삽입 ({count})",
|
||
insertSelectedColumnsDetail: "열을 선택한 후 한 번에 삽입합니다",
|
||
selectColumnsBeforeInsert: "먼저 하나 이상의 열을 선택하세요",
|
||
tableAlias: "테이블 별칭",
|
||
functionDescriptions: {
|
||
COUNT: "행 수를 반환합니다",
|
||
SUM: "숫자 컬럼의 합을 반환합니다",
|
||
AVG: "숫자 컬럼의 평균을 반환합니다",
|
||
MIN: "최솟값을 반환합니다",
|
||
MAX: "최댓값을 반환합니다",
|
||
GROUP_CONCAT: "그룹 값을 문자열로 이어 붙입니다",
|
||
STRING_AGG: "그룹 문자열을 이어 붙입니다",
|
||
CONCAT: "여러 문자열을 이어 붙입니다",
|
||
CONCAT_WS: "구분자로 문자열을 이어 붙입니다",
|
||
SUBSTRING: "부분 문자열을 추출합니다",
|
||
REPLACE: "문자열의 내용을 바꿉니다",
|
||
TRIM: "선행/후행 공백을 제거합니다",
|
||
UPPER: "대문자로 변환합니다",
|
||
LOWER: "소문자로 변환합니다",
|
||
LENGTH: "문자열 길이를 반환합니다",
|
||
REGEXP_REPLACE: "정규 표현식으로 바꿉니다",
|
||
DATE_FORMAT: "주어진 형식으로 날짜를 표시합니다",
|
||
DATEDIFF: "두 날짜 사이의 차이를 계산합니다",
|
||
DATE_ADD: "날짜에 간격을 더합니다",
|
||
DATE_SUB: "날짜에서 간격을 뺍니다",
|
||
EXTRACT: "날짜의 일부를 추출합니다",
|
||
NOW: "현재 날짜와 시간을 반환합니다",
|
||
CURRENT_DATE: "현재 날짜를 반환합니다",
|
||
CURRENT_TIME: "현재 시간을 반환합니다",
|
||
CURRENT_TIMESTAMP: "현재 날짜와 시간을 반환합니다",
|
||
CURDATE: "현재 날짜를 반환합니다",
|
||
CURTIME: "현재 시간을 반환합니다",
|
||
LOCALTIME: "현재 로컬 시간을 반환합니다",
|
||
LOCALTIMESTAMP: "현재 로컬 날짜와 시간을 반환합니다",
|
||
UTC_DATE: "현재 UTC 날짜를 반환합니다",
|
||
UTC_TIME: "현재 UTC 시간을 반환합니다",
|
||
UTC_TIMESTAMP: "현재 UTC 날짜와 시간을 반환합니다",
|
||
SYSDATE: "현재 날짜와 시간을 반환합니다",
|
||
DATE: "날짜 부분을 추출합니다",
|
||
TIME: "시간 부분을 추출합니다",
|
||
TIMESTAMPDIFF: "두 날짜/시간의 차이를 반환합니다",
|
||
YEAR: "연도를 추출합니다",
|
||
MONTH: "월을 추출합니다",
|
||
DAY: "일을 추출합니다",
|
||
HOUR: "시를 추출합니다",
|
||
MINUTE: "분을 추출합니다",
|
||
SECOND: "초를 추출합니다",
|
||
DAYOFWEEK: "요일 인덱스를 반환합니다",
|
||
DAYOFYEAR: "연중 몇 번째 날인지 반환합니다",
|
||
LAST_DAY: "해당 월의 마지막 날을 반환합니다",
|
||
STR_TO_DATE: "문자열을 날짜로 변환합니다",
|
||
IF: "조건에 따라 값을 반환합니다",
|
||
LEFT: "왼쪽부터 지정한 수만큼의 문자를 반환합니다",
|
||
RIGHT: "오른쪽부터 지정한 수만큼의 문자를 반환합니다",
|
||
SUBSTRING_INDEX: "구분자 개수 기준으로 그 앞의 부분 문자열을 반환합니다",
|
||
CHAR_LENGTH: "문자 수를 반환합니다",
|
||
INSTR: "부분 문자열의 위치를 반환합니다",
|
||
LOCATE: "부분 문자열의 위치를 반환합니다",
|
||
LPAD: "지정한 길이가 되도록 왼쪽을 채웁니다",
|
||
RPAD: "지정한 길이가 되도록 오른쪽을 채웁니다",
|
||
FIND_IN_SET: "쉼표로 구분된 목록에서의 인덱스를 반환합니다",
|
||
RAND: "무작위 부동소수점 값을 반환합니다",
|
||
MD5: "MD5 해시를 반환합니다",
|
||
SHA1: "SHA1 해시를 반환합니다",
|
||
SHA2: "SHA2 해시를 반환합니다",
|
||
ROUND: "지정한 소수점 자리로 반올림합니다",
|
||
FLOOR: "내림합니다",
|
||
CEIL: "올림합니다",
|
||
ABS: "절댓값을 반환합니다",
|
||
MOD: "나눗셈의 나머지를 반환합니다",
|
||
COALESCE: "첫 번째로 NULL이 아닌 인자를 반환합니다",
|
||
IFNULL: "NULL인 경우 대체 값을 반환합니다",
|
||
NULLIF: "인자가 같으면 NULL을 반환합니다",
|
||
CAST: "표현식을 대상 타입으로 변환합니다",
|
||
JSON_EXTRACT: "JSON에서 값을 추출합니다",
|
||
JSON_VALUE: "JSON에서 스칼라 값을 추출합니다",
|
||
JSON_OBJECT: "JSON 객체를 만듭니다",
|
||
JSON_ARRAY: "JSON 배열을 만듭니다",
|
||
},
|
||
},
|
||
contextMenu: {
|
||
executeSelection: "선택 영역 실행",
|
||
executeCurrent: "SQL 실행",
|
||
export: "내보내기",
|
||
exportQueryResultTo: "현재 쿼리 결과를 {format}(으)로 내보내기",
|
||
copySelection: "선택 영역 복사",
|
||
copySelectionAsRichText: "서식 있는 텍스트로 복사",
|
||
screenshotSelection: "선택한 코드 스크린샷",
|
||
commentSelection: "선택 항목 주석 처리",
|
||
blockCommentSelection: "선택 항목 블록 주석 처리",
|
||
formatSelectionSql: "선택한 SQL 서식 지정",
|
||
compressSelectionSql: "선택한 SQL 압축",
|
||
cutSelection: "선택 영역 잘라내기",
|
||
pasteFromClipboard: "붙여넣기",
|
||
pasteClipboardReadFailed: "클립보드 읽기 실패: {message}",
|
||
sendToAi: "AI로 보내기",
|
||
uppercaseSelection: "대문자로 변환",
|
||
lowercaseSelection: "소문자로 변환",
|
||
delimitedList: "구분자 목록으로 변환",
|
||
addNextSelectionOccurrence: "다음 일치 항목 선택 추가",
|
||
selectAllSelectionOccurrences: "모든 일치 항목 선택",
|
||
expandSelectStar: "*을(를) 열로 확장",
|
||
expandSelectStarUnavailable: "이 테이블의 열을 불러올 수 없습니다",
|
||
findReplace: "찾기/바꾸기",
|
||
deleteEmptyLines: "빈 줄 삭제",
|
||
selectAll: "모두 선택",
|
||
convertNamingStyle: "네이밍 스타일 전환",
|
||
},
|
||
delimitedList: {
|
||
title: "구분자 목록으로 변환",
|
||
columnDelimiter: "열 구분자",
|
||
resultDelimiter: "결과 구분자",
|
||
quoteChar: "인용 부호",
|
||
wrapColumn: "줄바꿈 열",
|
||
prefixText: "접두 텍스트",
|
||
suffixText: "접미 텍스트",
|
||
preview: "미리보기",
|
||
emptyPreview: "미리볼 내용이 없습니다",
|
||
confirm: "확인",
|
||
selectFirst: "목록 텍스트를 먼저 선택하세요",
|
||
},
|
||
search: {
|
||
find: "찾기",
|
||
replace: "바꾸기",
|
||
replaceAll: "모두 바꾸기",
|
||
caseSensitive: "대소문자 구분",
|
||
regex: "정규 표현식",
|
||
collapseReplace: "바꾸기 접기",
|
||
expandReplace: "바꾸기 펼치기",
|
||
prevMatch: "이전 (Shift+Enter)",
|
||
nextMatch: "다음 (Enter)",
|
||
close: "닫기 (Esc)",
|
||
noResults: "결과 없음",
|
||
inSelection: "선택 영역 내",
|
||
},
|
||
noExecutableStatementAtCursor: "커서 위치에 실행 가능한 구문이 없습니다.",
|
||
executionPicker: {
|
||
title: "실행 대상",
|
||
currentStatement: "현재 SQL",
|
||
allStatements: "전체 SQL",
|
||
currentCommand: "현재 명령",
|
||
allCommands: "전체 명령",
|
||
},
|
||
previewChanges: "변경 사항 미리 보기",
|
||
previewChangesComment: "변경 미리 보기(드라이 런): {operation} 문",
|
||
previewChangesFailed: "변경 미리 보기 실패.",
|
||
previewChangesNoStatement: "변경 사항을 미리 보려면 UPDATE / INSERT / DELETE 문을 선택하거나 커서를 해당 문에 놓으십시오.",
|
||
},
|
||
tabs: {
|
||
sql: "SQL",
|
||
emptyGroup: "열려 있는 탭 없음",
|
||
table: "테이블",
|
||
tableData: "테이블 데이터",
|
||
redis: "Redis",
|
||
etcd: "etcd",
|
||
etcdDashboard: "etcd 대시보드",
|
||
zookeeper: "ZooKeeper",
|
||
consul: "Consul",
|
||
mongo: "Mongo",
|
||
gridfs: "GridFS",
|
||
vector: "Vector",
|
||
databases: "데이터베이스",
|
||
objects: "객체",
|
||
users: "사용자 및 권한",
|
||
executionSummary: "요약",
|
||
messages: "메시지",
|
||
tooltipTitle: "제목:",
|
||
tooltipFilePath: "파일 경로:",
|
||
tooltipFileStatus: "파일 상태:",
|
||
externalFileMissing: "DBX 외부에서 삭제되거나 이동됨",
|
||
tooltipConnection: "연결:",
|
||
tooltipGroup: "그룹:",
|
||
tooltipDatabase: "데이터베이스:",
|
||
tooltipTable: "테이블:",
|
||
tooltipTableComment: "테이블 주석:",
|
||
tooltipCollection: "컬렉션:",
|
||
tooltipSchema: "스키마:",
|
||
resultN: "결과 {n}",
|
||
runN: "실행 {n}",
|
||
resultRuns: "결과 실행",
|
||
resultSets: "결과 집합",
|
||
allResults: "전체 결과 ({count})",
|
||
searchResults: "번호, 이름 또는 SQL 검색",
|
||
noMatchingResults: "일치하는 결과가 없습니다",
|
||
removeRun: "실행 {n} 제거",
|
||
pinResultRun: "결과 탭 고정",
|
||
unpinResultRun: "결과 탭 고정 해제",
|
||
unpinAllResultRuns: "모든 결과 탭 고정 해제",
|
||
closeOtherResultRuns: "다른 결과 탭 닫기",
|
||
closeResultRunsToLeft: "왼쪽 결과 탭 닫기",
|
||
closeResultRunsToRight: "오른쪽 결과 탭 닫기",
|
||
closeResult: "결과 닫기",
|
||
autoKeepResults: "쿼리 결과 자동 보관",
|
||
autoKeepResultsEnabled: "결과 자동 보관 활성화됨",
|
||
autoKeepResultsDisabled: "결과 자동 보관 비활성화됨",
|
||
autoRefresh: "결과 자동 새로고침",
|
||
autoRefreshShort: "자동",
|
||
autoRefreshEvery: "{seconds}초마다 새로고침",
|
||
startAutoRefresh: "자동 새로고침 시작",
|
||
stopAutoRefresh: "자동 새로고침 중지",
|
||
missingResultRun: "이 결과는 더 이상 사용할 수 없습니다",
|
||
exportResultArchive: "결과 저장",
|
||
importResultArchive: "결과 아카이브 가져오기",
|
||
importedResultArchive: "결과를 가져왔습니다",
|
||
resultArchiveExported: "결과를 내보냈습니다",
|
||
resultArchiveImported: "결과를 가져왔습니다",
|
||
resultArchiveUnavailable: "내보낼 저장된 결과가 없습니다",
|
||
resultArchiveImportInvalid: "이 결과 아카이브를 열 수 없습니다",
|
||
resultArchiveExportFailed: "결과 내보내기에 실패했습니다: {message}",
|
||
resultArchiveImportFailed: "결과 가져오기에 실패했습니다: {message}",
|
||
scrollLeft: "탭을 왼쪽으로 스크롤",
|
||
scrollRight: "탭을 오른쪽으로 스크롤",
|
||
openTabs: "열린 탭",
|
||
openInNewWindow: "새 창에서 열기",
|
||
searchOpenTabs: "열린 탭 검색...",
|
||
collapseTabBar: "탭 표시줄 접기",
|
||
expandTabBar: "탭 표시줄 펼치기",
|
||
switcherTitle: "탭 전환",
|
||
switcherHint: "계속 눌러 이동하고 놓으면 전환",
|
||
noMatchingTabs: "일치하는 탭이 없습니다",
|
||
fixedTabs: "고정 탭",
|
||
openDataTabs: "열린 테이블",
|
||
editGroupTitle: "그룹 편집: {name}",
|
||
groupName: "그룹 이름",
|
||
groupColor: "그룹 색상",
|
||
groupColorAuto: "기본 색상 사용",
|
||
groupColorCustom: "사용자 지정 색상 선택",
|
||
resetGroup: "초기화",
|
||
settingsSaveFailed: "탭 설정을 저장하지 못했습니다: {message}",
|
||
},
|
||
databaseBrowser: {
|
||
search: "데이터베이스 검색...",
|
||
empty: "데이터베이스를 찾을 수 없습니다",
|
||
loadFailed: "데이터베이스를 불러올 수 없습니다: {message}",
|
||
defaultCharset: "문자 집합",
|
||
defaultCollation: "데이터 정렬",
|
||
},
|
||
gridfsBrowser: {
|
||
bucketCount: "버킷",
|
||
fileCount: "파일",
|
||
name: "이름",
|
||
totalSize: "크기",
|
||
chunkSize: "청크 크기",
|
||
uploadDate: "업로드 날짜",
|
||
contentType: "콘텐츠 유형",
|
||
metadata: "메타데이터",
|
||
selectBucket: "조회하거나 열 GridFS 버킷을 선택하세요.",
|
||
selectFile: "조회하거나 관리할 GridFS 파일을 선택하세요.",
|
||
emptyBuckets: "GridFS 버킷이 없습니다. 파일 저장을 시작하려면 버킷을 만드세요.",
|
||
emptyFiles: "이 버킷에 아직 파일이 없습니다. 시작하려면 파일을 업로드하세요.",
|
||
createBucket: "새 버킷",
|
||
openBucket: "버킷 열기",
|
||
deleteBucket: "버킷 삭제",
|
||
createTitle: "GridFS 버킷 만들기",
|
||
deleteTitle: "GridFS 버킷 삭제",
|
||
deleteMessage: "선택한 GridFS 버킷과 그 안의 모든 파일을 삭제하시겠습니까?",
|
||
bucketName: "버킷 이름",
|
||
bucketNamePlaceholder: "example_bucket",
|
||
bucketCreated: "버킷 {bucket}을(를) 만들었습니다.",
|
||
bucketDeleted: "버킷 {bucket}을(를) 삭제했습니다.",
|
||
uploadFile: "파일 업로드",
|
||
downloadFile: "파일 다운로드",
|
||
downloadSelected: "선택 항목 다운로드",
|
||
deleteFile: "파일 삭제",
|
||
selectedCount: "{count}개 선택됨",
|
||
deleteFileTitle: "GridFS 파일 삭제",
|
||
deleteFileMessage: "이 GridFS 버킷에서 선택한 파일을 삭제하시겠습니까?",
|
||
fileUploaded: "{fileName}을(를) 업로드했습니다.",
|
||
fileDeleted: "{fileName}을(를) 삭제했습니다.",
|
||
},
|
||
executionSummary: {
|
||
empty: "요약 없음",
|
||
executing: "실행 중...",
|
||
finished: "실행 완료",
|
||
statement: "구문",
|
||
sql: "SQL",
|
||
status: "상태",
|
||
type: "유형",
|
||
rows: "행",
|
||
affected: "영향 받은 행",
|
||
time: "시간",
|
||
success: "성공",
|
||
error: "오류",
|
||
returnedTable: "{count}열 결과 테이블을 반환했습니다",
|
||
noTable: "반환된 결과 테이블이 없습니다",
|
||
noSql: "SQL을 가져올 수 없습니다",
|
||
lineColumn: "{line}행 {column}열",
|
||
navigationHint: "행을 클릭하여 SQL을 미리 보고 두 번 클릭하여 편집기에서 선택하세요.",
|
||
recoveryPrompt: "구문 #{statement} 실행에 실패하여 나머지 {count}개 구문이 실행되지 않았습니다.",
|
||
stop: "중지",
|
||
retry: "다시 시도",
|
||
skipAndContinue: "건너뛰고 계속",
|
||
skipAll: "모든 오류 건너뛰기",
|
||
skipAllHint: "계속 실행하고 이 배치의 이후 오류를 자동으로 건너뜁니다",
|
||
statuses: {
|
||
pending: "대기 중",
|
||
running: "실행 중",
|
||
success: "성공",
|
||
error: "오류",
|
||
skipped: "실행 안 됨",
|
||
cancelled: "취소됨",
|
||
},
|
||
},
|
||
queryMessages: {
|
||
empty: "메시지 없음",
|
||
code: "코드: {code}",
|
||
},
|
||
chart: {
|
||
title: "차트",
|
||
type: "유형",
|
||
line: "꺾은선",
|
||
bar: "막대",
|
||
pie: "파이",
|
||
noNumericData: "차트에 사용할 숫자 데이터가 없습니다",
|
||
},
|
||
grid: {
|
||
rows: "{count}행",
|
||
totalRows: "전체 {count}행",
|
||
loadedRows: "{count}행 로드됨",
|
||
totalRowCount: "(전체 {count})",
|
||
totalRowCountWithAction: "({button}전체 {count})",
|
||
totalRowCountAtLeast: "(최소 {count})",
|
||
totalRowCountEstimated: "(약 {count})",
|
||
totalRowCountLoading: "(집계 중...)",
|
||
loadingMore: "데이터를 더 불러오는 중...",
|
||
pageJumpLoading: "{page}페이지로 이동 중",
|
||
pageJumpProgress: "완료된 요청 {current}/{total}",
|
||
esDeepPageJumpConfirmTitle: "Elasticsearch 심층 페이지 이동 확인",
|
||
esDeepPageJumpConfirmMessage:
|
||
"Elasticsearch의 search_after는 지정한 페이지로 바로 이동할 수 없습니다. DBX는 누락된 커서를 순서대로 가져와야 하며 이전 페이지로 이동할 때는 1페이지부터 다시 시작합니다. {page}페이지로 이동하면 약 {requests}개의 쿼리가 전송됩니다. 시간이 오래 걸리고 클러스터 부하가 증가할 수 있습니다. 계속하시겠습니까?",
|
||
esDeepPageJumpContinue: "계속 이동",
|
||
allLoaded: "모두 로드됨",
|
||
calculateTotalRows: "전체 행 수 집계",
|
||
calculateTotalRowsInline: "(전체 행 수 집계)",
|
||
calculateTotalRowsFailed: "집계 실패: {message}",
|
||
rowsAffected: "{count}행 영향 받음",
|
||
querySuccess: "쿼리가 성공적으로 실행되었습니다",
|
||
noRows: "데이터 없음",
|
||
noRowsDescription: "이 결과 집합에 레코드가 없습니다.",
|
||
noSearchResults: "일치 항목 없음",
|
||
noSearchResultsDescription: "다른 키워드를 시도해 보세요.",
|
||
noFilteredRows: "필터와 일치하는 행이 없습니다",
|
||
noFilteredRowsDescription: "검색 텍스트나 행 상태 필터를 조정하세요.",
|
||
copy: "복사",
|
||
copyExtractorSmart: "스마트 복사",
|
||
copyExtractorRaw: "셀 원문",
|
||
copyExtractorWithHeaders: "머리글 포함 {format}",
|
||
copyExtractorOneRow: "단일 행",
|
||
copyExtractorJsonArray: "JSON 배열",
|
||
copyExtractorSqlInList: "SQL IN 목록",
|
||
copyExtractorSqlInserts: "SQL INSERT",
|
||
copyExtractorSqlInsertsWithPrimaryKeys: "SQL INSERT (기본 키 포함)",
|
||
copyExtractorSqlInsertsWithoutPrimaryKeys: "SQL INSERT (기본 키 제외)",
|
||
copyExtractorSqlUpdates: "SQL UPDATE",
|
||
copyExtractorSqlSelect: "SQL SELECT",
|
||
copyExtractorWhereClause: "WHERE 절",
|
||
copyExtractorPipeSeparated: "파이프(|) 구분",
|
||
copyExtractorPretty: "보기 좋은 표",
|
||
copyExtractorConfigure: "데이터 추출기 설정…",
|
||
copyExtractorDefaultFormat: "기본 복사 동작",
|
||
copyExtractorFormat: "추출기",
|
||
copyExtractorColumnSeparator: "열 구분자",
|
||
copyExtractorRowSeparator: "행 구분자",
|
||
copyExtractorNullText: "NULL 텍스트",
|
||
copyExtractorQuote: "인용 부호",
|
||
copyExtractorQuotePolicy: "인용",
|
||
copyExtractorQuoteMinimal: "필요시",
|
||
copyExtractorQuoteAlways: "항상",
|
||
copyExtractorQuoteNever: "안 함",
|
||
copyExtractorIncludeHeader: "컬럼 머리글 포함",
|
||
copyExtractorIncludeRowHeader: "행 번호 포함",
|
||
copyExtractorSkipComputed: "계산된 컬럼 건너뛰기",
|
||
copyExtractorSkipGenerated: "생성된 컬럼 건너뛰기",
|
||
copyExtractorExcludePrimaryKeys: "기본 키 제외",
|
||
copyExtractorInsertMode: "INSERT 구문",
|
||
copyExtractorInsertMerged: "행 병합",
|
||
copyExtractorInsertRowByRow: "행별 한 구문",
|
||
copyExtractorPrettyJson: "JSON 보기 좋게",
|
||
copyExtractorCamelCaseJsonFields: "snake_case 필드 이름을 camelCase로 변환",
|
||
copyExtractorPreview: "미리보기 (현재 선택)",
|
||
copyExtractorEmptySelection: "추출기 출력을 미리보려면 데이터를 선택하세요.",
|
||
copyExtractorUnsupportedSelection: "이 추출기는 모든 행에서 동일한 컬럼이 선택되어야 합니다.",
|
||
copyExtractorPreviewTruncated: "선택한 {count}행 중 처음 100행을 미리보는 중.",
|
||
copyExtractorWarningOmittedColumns: "복사된 출력에서 다음 컬럼이 생략되었습니다: {columns}.",
|
||
copyExtractorWarningDuplicateJsonColumns: "데이터 손실을 방지하기 위해 중복된 JSON 컬럼 이름이 변경되었습니다.",
|
||
copyExtractorValidation: {
|
||
"column-separator-empty": "열 구분자는 비워둘 수 없습니다.",
|
||
"row-separator-empty": "행 구분자는 비워둘 수 없습니다.",
|
||
"separator-too-long": "구분자는 최대 8자까지 가능합니다.",
|
||
"null-text-too-long": "NULL 텍스트는 최대 64자까지 가능합니다.",
|
||
"separators-overlap": "열과 행 구분자는 겹칠 수 없습니다.",
|
||
"invalid-quote": "인용 부호는 정확히 한 자여야 합니다.",
|
||
"quote-conflicts": "인용 부호는 열이나 행 구분자의 일부일 수 없습니다.",
|
||
},
|
||
mongoJsonPreview: "JSON 미리보기",
|
||
mongoJsonPreviewEmpty: "미리보려면 MongoDB 문서를 선택하세요.",
|
||
copyJson: "JSON 복사",
|
||
copyDdl: "DDL 복사",
|
||
hoverSearchPlaceholder: "열 검색…",
|
||
hoverSearchNoResult: "일치하는 열 없음",
|
||
copyCell: "셀 복사",
|
||
copyRow: "전체 행 복사(JSON 객체)",
|
||
copyColumnJson: "컬럼 복사 (JSON)",
|
||
copyColumnNames: "컬럼 이름 복사",
|
||
copyColumnNamesSelected: "선택한 컬럼 이름 복사 ({count})",
|
||
copyColumnNamesTitle: "컬럼 이름 복사 ({count})",
|
||
copyColumnNamesSeparator: "컬럼 구분자",
|
||
copyColumnNamesQuote: "컬럼 이름 인용",
|
||
copyColumnNamesPreview: "미리보기",
|
||
copyAll: "모두 복사 (TSV)",
|
||
selectionSum: "합계: {value}",
|
||
selectionAverage: "평균: {value}",
|
||
selectionCells: "{count}개 셀",
|
||
clearSelection: "선택 해제",
|
||
export: "내보내기",
|
||
exportCsv: "CSV 내보내기",
|
||
exportXlsx: "XLSX 내보내기",
|
||
exportXlsxWithSql: "SQL 포함 XLSX 내보내기",
|
||
exportCurrentPageCsv: "현재 페이지를 CSV로 내보내기",
|
||
exportCurrentPageXlsx: "현재 페이지를 XLSX로 내보내기",
|
||
exportCurrentPageXlsxWithSql: "현재 페이지를 SQL 포함 XLSX로 내보내기",
|
||
exportCurrentPageJson: "현재 페이지를 JSON으로 내보내기",
|
||
exportCurrentPageMarkdown: "현재 페이지를 Markdown으로 내보내기",
|
||
exportCurrentPageSql: "현재 페이지를 SQL INSERT로 내보내기",
|
||
exportCurrentPageTxt: "현재 페이지를 TXT로 내보내기",
|
||
exportCurrentResultCsv: "현재 결과 집합 전체를 CSV로 내보내기",
|
||
exportCurrentResultXlsx: "현재 결과 집합 전체를 XLSX로 내보내기",
|
||
exportCurrentResultXlsxWithSql: "현재 결과 집합 전체를 SQL 포함 XLSX로 내보내기",
|
||
exportCurrentResultJson: "현재 결과 집합 전체를 JSON으로 내보내기",
|
||
exportCurrentResultMarkdown: "현재 결과 집합 전체를 Markdown으로 내보내기",
|
||
exportCurrentResultSql: "현재 결과 집합 전체를 SQL INSERT로 내보내기",
|
||
exportCurrentResultTxt: "현재 결과 집합 전체를 TXT로 내보내기",
|
||
exportAllResultsXlsx: "이번 실행의 모든 결과 집합을 XLSX로 내보내기",
|
||
exportAllResultsXlsxWithSql: "이번 실행의 모든 결과 집합을 SQL 포함 XLSX로 내보내기",
|
||
exportJson: "JSON 내보내기",
|
||
exportMarkdown: "Markdown 내보내기",
|
||
exportSql: "SQL INSERT 내보내기",
|
||
sqlInsertModeTitle: "SQL INSERT 내보내기 모드",
|
||
sqlInsertModePrompt: "SQL INSERT 파일에 행을 기록할 방식을 선택하세요:",
|
||
sqlInsertModeBatch: "일괄 추가",
|
||
sqlInsertModeBatchDescription: "여러 행을 각 INSERT 문에 결합하여 파일 크기를 줄이고 실행 속도를 높입니다.",
|
||
sqlInsertModeSingle: "문 하나당 한 행",
|
||
sqlInsertModeSingleDescription: "행마다 완전한 INSERT 문을 작성하여 개별 실행과 문제 해결을 쉽게 합니다.",
|
||
exportTxt: "TXT 내보내기",
|
||
exportSelectedRowsCsv: "선택한 행을 CSV로 내보내기",
|
||
exportSelectedRowsXlsx: "선택한 행을 XLSX로 내보내기",
|
||
exportSelectedRowsXlsxWithSql: "선택한 행을 SQL 포함 XLSX로 내보내기",
|
||
exportSelectedRowsJson: "선택한 행을 JSON으로 내보내기",
|
||
exportSelectedRowsMarkdown: "선택한 행을 Markdown으로 내보내기",
|
||
exportSelectedRowsSql: "선택한 행을 SQL INSERT로 내보내기",
|
||
exportSelectedRowsTxt: "선택한 행을 TXT로 내보내기",
|
||
exported: "내보냈습니다",
|
||
exportFailed: "내보내기 실패: {message}",
|
||
copied: "복사했습니다",
|
||
cut: "잘라냈습니다",
|
||
copyFailed: "복사 실패: {message}",
|
||
previewSqlEmpty: "미리볼 보류 중인 SQL 변경이 없습니다",
|
||
renderMode: "렌더링 모드",
|
||
domRenderMode: "DOM",
|
||
canvasRenderMode: "Canvas",
|
||
renderModeHint: "Canvas 렌더링과 DOM 폴백 그리드 사이를 전환합니다.",
|
||
tableFontFamily: "테이블 글꼴",
|
||
tableFontSize: "테이블 글꼴 크기",
|
||
filter: "필터",
|
||
conditionHistoryEmpty: "아직 기록이 없습니다",
|
||
conditionHistoryNoMatches: "일치하는 기록이 없습니다",
|
||
filterBuilder: "필터",
|
||
filterBuilderTitle: "필터",
|
||
filterBuilderHint: "클릭 기반 조건을 만들고 WHERE 입력과 결합하세요.",
|
||
filterView: "필터 보기",
|
||
filterQuickView: "빠른 보기",
|
||
filterConditionView: "조건 보기",
|
||
filterTextView: "텍스트 보기",
|
||
resizeFilterPanel: "필터 패널 높이 조절",
|
||
filterConditionPanel: "필터 조건",
|
||
filterManualWhere: "수동 WHERE",
|
||
filterSqlPreview: "SQL 조건 미리보기",
|
||
filterSqlPreviewEmpty: "아직 유효한 필터 조건이 없습니다",
|
||
filterSqlPreviewReady: "조건이 준비되었습니다. 적용하면 결과가 새로 고쳐집니다",
|
||
copyFilterSql: "SQL 조건 복사",
|
||
filterSqlCopied: "SQL 조건을 복사했습니다",
|
||
filterBuilderSummary: "{count}개 규칙",
|
||
filterBuilderAddRule: "규칙 추가",
|
||
filterBuilderApplyOnly: "이 조건만 필터링",
|
||
filterBuilderCompleteRuleFirst: "먼저 이 필터 조건을 완성하세요",
|
||
filterBuilderEnableRule: "조건 활성화",
|
||
filterBuilderDisableRule: "조건 비활성화",
|
||
filterBuilderReorderRule: "드래그하거나 방향키로 조건 순서 변경",
|
||
filterBuilderColumn: "컬럼",
|
||
filterBuilderSearchColumns: "컬럼 검색...",
|
||
filterBuilderNoMatchingColumns: "일치하는 컬럼이 없습니다",
|
||
filterBuilderValue: "값",
|
||
filterBuilderTextValue: "<?>",
|
||
filterBuilderValueTypeAuto: "자동",
|
||
filterBuilderValueTypeString: "문자열",
|
||
filterBuilderValueTypeNumber: "숫자",
|
||
filterBuilderValueTypeBoolean: "불리언",
|
||
filterBuilderValueTypeObjectId: "ObjectId",
|
||
filterBuilderValueTypeDate: "날짜",
|
||
filterBuilderValueTypeInt32: "Int32",
|
||
filterBuilderValueTypeInt64: "Int64",
|
||
filterBuilderValueTypeDecimal128: "Decimal128",
|
||
filterBuilderValueTypeJson: "JSON",
|
||
filterBuilderValueShortcutHint: "Shift+Enter로 조건을 추가할 수 있습니다",
|
||
filterBuilderValues: "값 (쉼표 또는 줄바꿈으로 구분)",
|
||
filterBuilderRangeStart: "시작 값",
|
||
filterBuilderRangeEnd: "끝 값",
|
||
filterBuilderNoValue: "값 필요 없음",
|
||
filterBuilderEmpty: "행 필터링을 시작하려면 규칙을 추가하세요.",
|
||
resetFilterBuilder: "규칙 초기화",
|
||
filterBuilderEquals: "같음",
|
||
filterBuilderNotEquals: "같지 않음",
|
||
filterBuilderContains: "포함",
|
||
filterBuilderNotContains: "포함하지 않음",
|
||
filterBuilderBeginsWith: "…으로 시작",
|
||
filterBuilderEndsWith: "…으로 끝",
|
||
filterBuilderGreaterThan: "보다 큼",
|
||
filterBuilderGreaterThanOrEqual: "크거나 같음",
|
||
filterBuilderLessThan: "보다 작음",
|
||
filterBuilderLessThanOrEqual: "작거나 같음",
|
||
filterBuilderIn: "목록 내",
|
||
filterBuilderNotIn: "목록 외",
|
||
filterBuilderBetween: "범위 내",
|
||
filterBuilderNotBetween: "범위 외",
|
||
filterBuilderIsNull: "NULL임",
|
||
filterBuilderIsNotNull: "NULL이 아님",
|
||
filterBuilderIsBlank: "비어 있음(NULL 또는 빈 문자열)",
|
||
filterBuilderIsNotBlank: "비어 있지 않음(NULL도 빈 문자열도 아님)",
|
||
columnActions: "컬럼 작업",
|
||
localFilter: "로컬 값 필터",
|
||
localFilterFor: "'{column}' 로컬 값",
|
||
databaseValueFilter: "데이터베이스 값 필터",
|
||
databaseValueFilterFor: "'{column}' 데이터베이스 값",
|
||
columnFormatter: "컬럼 포매터",
|
||
columnFormatterActive: "이 열에 서식이 적용되어 있습니다",
|
||
columnFormatterFor: "'{column}' 포매터",
|
||
columnFormatterHint: "표시만 서식 지정하며 원시 값은 변경되지 않습니다.",
|
||
formatterType: "유형",
|
||
formatterDatetime: "Unix 타임스탬프",
|
||
formatterJsonPath: "JSON 경로",
|
||
formatterMask: "텍스트 마스크",
|
||
formatterCustomTemplate: "사용자 지정 템플릿",
|
||
formatterTimestampUnit: "타임스탬프 단위",
|
||
formatterUnitAuto: "자동",
|
||
formatterUnitSeconds: "초",
|
||
formatterUnitMilliseconds: "밀리초",
|
||
formatterDatetimePattern: "날짜/시간 패턴",
|
||
formatterDatetimePatternPlaceholder: "날짜/시간 패턴 선택 또는 입력",
|
||
formatterDatetimePatternEmpty: "기본 ISO8601 형식",
|
||
formatterDatetimeTimezone: "시간대",
|
||
formatterDatetimeTimezonePlaceholder: "시간대 선택",
|
||
formatterJsonPathInput: "JSON 경로",
|
||
formatterMaskPrefix: "표시 접두",
|
||
formatterMaskSuffix: "표시 접미",
|
||
formatterSavedCustom: "저장된 템플릿",
|
||
formatterNewCustom: "새 템플릿",
|
||
formatterCustomName: "템플릿 이름",
|
||
formatterCustomNamePlaceholder: "예: 사용자 라벨",
|
||
formatterCustomTemplateInput: "템플릿",
|
||
formatterCustomTemplateHint: "사용 가능한 변수: ${value}, ${upper}, ${lower}, ${length}. 목록에 저장하려면 이름을 지정하세요.",
|
||
formatterPreview: "미리보기",
|
||
saveFormatter: "저장",
|
||
clearFormatter: "지우기",
|
||
searchValues: "값 검색...",
|
||
loadingValues: "값을 불러오는 중...",
|
||
serverValuesLimited: "처음 {count}개 값 표시 중",
|
||
filterTypedValue: "'{value}' 사용",
|
||
value: "값",
|
||
count: "개수",
|
||
applyFilter: "필터 적용",
|
||
clearLocalFilters: "로컬 값 필터 지우기",
|
||
clearLocalFiltersShort: "로컬 지우기",
|
||
localFiltersActive: "로컬 값 필터 {count}개",
|
||
localFilterMoreValues: " 외 {count}개",
|
||
columnVisibility: "컬럼",
|
||
columnVisibilityHint: "최소 한 개의 컬럼은 표시 상태를 유지합니다.",
|
||
columnReorderHint: "드래그하여 컬럼 순서를 변경합니다.",
|
||
columnReorderSearchHint: "컬럼 순서를 변경하려면 검색을 지우세요.",
|
||
searchColumns: "컬럼 검색...",
|
||
dragColumnToReorder: "컬럼 머리글을 드래그하여 순서 변경",
|
||
invertColumnVisibility: "반전",
|
||
resetColumnOrder: "순서 초기화",
|
||
showAllColumns: "모두 표시",
|
||
viewOptions: "보기 옵션",
|
||
resultRunDisplayMode: "결과 탭",
|
||
resultRunDisplayList: "목록",
|
||
resultRunDisplayTabs: "바둑판",
|
||
hideNullColumns: "NULL 숨기기",
|
||
hideNullColumnsHint: "현재 결과에서 값이 모두 NULL인 컬럼을 전환합니다.",
|
||
searchMode: "검색 모드",
|
||
searchModeHint: "Ctrl+F가 일치하는 행을 필터링할지, 모든 행을 표시하고 일치 항목을 강조할지 선택하세요.",
|
||
searchModeFilter: "필터",
|
||
searchModeHighlight: "강조",
|
||
colorizeDataTypes: "데이터 타입 색상",
|
||
numericColumnAlign: "숫자 컬럼 정렬",
|
||
numericColumnAlignLeft: "왼쪽",
|
||
numericColumnAlignRight: "오른쪽",
|
||
booleanDisplayMode: "불리언 표시",
|
||
booleanDisplayCheckbox: "체크",
|
||
booleanDisplayDropdown: "드롭다운",
|
||
moreValues: "{count}개 값 더, 결과를 좁히려면 계속 입력하세요",
|
||
filterByValue: "이 값으로 필터",
|
||
filterExcludeValue: "이 값 제외",
|
||
filterLike: "값 포함",
|
||
filterNotLike: "포함하지 않음",
|
||
filterLessThan: "값보다 작음",
|
||
filterGreaterThan: "값보다 큼",
|
||
filterIsNull: "NULL 값 표시",
|
||
filterIsNotNull: "NULL이 아닌 값 표시",
|
||
clearFilter: "필터 지우기",
|
||
sort: "정렬",
|
||
sortAscending: "오름차순 정렬",
|
||
sortDescending: "내림차순 정렬",
|
||
sortCurrentPageAscending: "현재 페이지 오름차순 정렬",
|
||
sortCurrentPageDescending: "현재 페이지 내림차순 정렬",
|
||
sortDatabaseAscending: "데이터베이스 오름차순 정렬",
|
||
sortDatabaseDescending: "데이터베이스 내림차순 정렬",
|
||
clearSort: "정렬 지우기",
|
||
freezeToColumn: "이 컬럼까지 고정",
|
||
freezeSelectedColumns: "선택한 컬럼 고정",
|
||
unfreezeColumns: "컬럼 고정 해제",
|
||
hideColumn: "이 컬럼 숨기기",
|
||
hideSelectedColumns: "선택한 컬럼 숨기기 ({count})",
|
||
showAllColumnsMenu: "모든 컬럼 표시",
|
||
pasted: "붙여넣었습니다!",
|
||
search: "검색...",
|
||
searchTruncatedValuesHint: "일부 긴 텍스트/JSON 값은 표시를 위해 잘렸습니다. 검색은 로드된 표시 내용만 대상으로 하며 SQL 쿼리보다 일치 수가 적을 수 있습니다.",
|
||
searchOrWhere: "검색 또는 WHERE 절 입력...",
|
||
applyWhere: "WHERE 적용",
|
||
filterRows: "행 필터",
|
||
filterAllRows: "전체 행",
|
||
filterChangedRows: "변경됨",
|
||
page: "{page}페이지",
|
||
jumpToPage: "{page}페이지로 이동",
|
||
rowsPerPage: "페이지당 행",
|
||
customRowsPerPage: "사용자 지정 행",
|
||
applyPageSize: "적용",
|
||
save: "저장",
|
||
discard: "저장 안 함",
|
||
dismiss: "닫기",
|
||
addRow: "행 추가",
|
||
insertMultipleRows: "여러 행 삽입…",
|
||
insertRowsTitle: "여러 행 삽입",
|
||
insertRowsDescription: "저장되지 않은 초안 행을 지정한 개수만큼 만듭니다. 저장 시 비어 있는 행은 무시되며, 저장 후 표시 순서는 현재 쿼리를 따릅니다.",
|
||
insertRowCountLabel: "행 수",
|
||
insertRowCountInvalid: "0보다 큰 정수를 입력하세요.",
|
||
insertRowsMaxHint: "최대 {max}행까지.",
|
||
insertRowsConfirm: "삽입",
|
||
insertAboveSelected: "선택 행 위에 삽입",
|
||
insertBelowSelected: "선택 행 아래에 삽입",
|
||
insertRowPositionLabel: "위치",
|
||
insertPositionAbove: "선택 행 위",
|
||
insertPositionBelow: "선택 행 아래",
|
||
insertPositionEnd: "데이터 끝",
|
||
quickEntryDraftPlaceholder: "새로 만들기",
|
||
cloneRow: "새 행으로 복제",
|
||
deleteRow: "행 삭제",
|
||
deleteRows: "{count}행 삭제",
|
||
cloneRows: "{count}개를 새 행으로 복제",
|
||
restoreRows: "{count}행 복원",
|
||
copyRows: "{count}행 복사(JSON 배열)",
|
||
copyColumnsJson: "{count}컬럼 복사 (JSON)",
|
||
selectedRows: "{count}행 선택됨",
|
||
restoreRow: "행 복원",
|
||
statusClean: "변경 없음",
|
||
statusNew: "새 항목",
|
||
statusEdited: "수정된 항목",
|
||
statusDeleted: "삭제된 항목",
|
||
pendingChanges: "{count}개 보류",
|
||
selectedCells: "{count}개 선택됨",
|
||
bulkEditSelection: "선택 항목 일괄 편집",
|
||
bulkEditTitle: "선택 항목 일괄 편집",
|
||
bulkEditDescription: "선택한 {count}개 셀을 이 값으로 설정합니다.",
|
||
bulkEditValuePlaceholder: "값 또는 NULL",
|
||
applyBulkEdit: "적용",
|
||
bulkEditSelectionScope: "선택한 셀만",
|
||
bulkEditSelectionScopeDescription: "선택한 셀 {count}개를 보류 중인 변경 사항에 추가합니다.",
|
||
bulkEditConditionalScope: "조건과 일치하는 모든 행",
|
||
bulkEditConditionalScopeDescription: "입력한 조건과 일치하는 데이터베이스의 모든 행에서 {column}을 업데이트합니다.",
|
||
bulkEditConditionalConditionSource: "일치 조건",
|
||
bulkEditConditionalUseCurrentFilter: "현재 테이블 필터 사용",
|
||
bulkEditConditionalUseCurrentFilterDescription: "이 테이블에 현재 적용된 데이터베이스 조건을 사용합니다.",
|
||
bulkEditConditionalBuildFilter: "일치 조건 설정",
|
||
bulkEditConditionalBuildFilterDescription: "SQL을 작성하지 않고 열, 연산자, 값을 선택합니다.",
|
||
bulkEditConditionalAdvancedWhere: "고급: WHERE SQL",
|
||
bulkEditConditionalAdvancedWhereDescription: "사용자 지정 SQL 조건을 작성합니다.",
|
||
conditionalBulkEditPreviewCount: "영향 받는 행 미리 보기",
|
||
conditionalBulkEditPreviewingCount: "미리 보는 중…",
|
||
conditionalBulkEditPreviewCountResult: "예상 영향 행 수: {count}",
|
||
conditionalBulkEditPreviewCountStale: "조건이 변경되었습니다. 다시 미리 보세요.",
|
||
conditionalBulkEditPreviewCountFailed: "영향 받는 행을 미리 볼 수 없습니다: {message}",
|
||
bulkEditConditionalWhere: "WHERE 조건(필수)",
|
||
bulkEditConditionalWherePlaceholder: "예: tenant_id = 1 AND status = 'pending'",
|
||
bulkEditConditionalWhereDescription: "WHERE 절 또는 조건만 입력하세요. 현재 테이블 필터가 있으면 미리 채워집니다.",
|
||
conditionalBulkEditUnavailable: "현재 선택 또는 필터에서는 조건부 일괄 편집을 더 이상 사용할 수 없습니다.",
|
||
conditionalBulkEditConditionRequired: "일치하는 모든 행을 업데이트하기 전에 일치 조건을 하나 이상 설정하세요.",
|
||
conditionalBulkEditPrepareFailed: "조건부 업데이트를 준비하지 못했습니다: {message}",
|
||
conditionalBulkEditConfirmTitle: "조건부 일괄 업데이트 확인",
|
||
conditionalBulkEditConfirmMessage: "실행 시 조건과 일치하는 모든 행을 즉시 업데이트하며 로드되지 않은 행도 포함됩니다. DBX는 신뢰할 수 있는 롤백 SQL을 생성할 수 없습니다.",
|
||
conditionalBulkEditConfirm: "업데이트 실행",
|
||
conditionalBulkEditAppliedCount: "일치하는 행 {count}개를 업데이트했습니다",
|
||
conditionalBulkEditApplied: "일치하는 행을 업데이트했습니다",
|
||
conditionalBulkEditPendingChanges: "조건과 일치하는 모든 행을 업데이트하기 전에 보류 중인 변경 사항을 저장하거나 취소하세요.",
|
||
generateValue: "값 생성",
|
||
generateEmptyString: "빈 문자열",
|
||
generateNull: "NULL",
|
||
generateCurrentDatetime: "현재 날짜/시간",
|
||
generateCurrentDate: "현재 날짜",
|
||
generateUuidV4: "UUID v4",
|
||
generateUuidV7: "UUID v7",
|
||
generateIncrementId: "증가 ID",
|
||
generateSnowflakeId: "Snowflake ID",
|
||
generateSequenceDescription: "선택한 {count}개 셀에 연속 값을 생성합니다. 시작 값을 입력하세요.",
|
||
generateStartInvalid: "시작 값은 정수여야 합니다",
|
||
generatedValuesApplied: "{count}개 값 생성됨",
|
||
cellDetails: "셀 상세",
|
||
cellDetailLayoutBottom: "아래로 이동",
|
||
cellDetailLayoutRight: "오른쪽으로 이동",
|
||
collapseCellDetailMetadata: "셀 메타데이터 접기",
|
||
expandCellDetailMetadata: "셀 메타데이터 펼치기",
|
||
openCellDetailsDialog: "셀 상세 열기",
|
||
rowDetails: "행 상세",
|
||
rowDetailsFor: "{row}행 상세",
|
||
openRowDetailsDialog: "행 상세 열기",
|
||
openColumnDetailsDialog: "컬럼 상세 열기",
|
||
columnDetailsFor: "{column} 컬럼 상세",
|
||
columnsCount: "{count}개 컬럼",
|
||
rowCount: "행",
|
||
rowsCount: "{count}행",
|
||
fieldIndex: "번호",
|
||
cellValue: "값",
|
||
valueEditor: "값 편집기",
|
||
hexViewer: "16진수 뷰어",
|
||
hexViewerByteCount: "{count}바이트",
|
||
hexViewerOffset: "오프셋",
|
||
hexViewerHex: "16진수",
|
||
hexViewerAscii: "ASCII",
|
||
hexViewerEmpty: "표시할 바이너리 바이트가 없습니다.",
|
||
imagePreview: "이미지 미리보기",
|
||
imageLoadFailed: "이미지를 불러오지 못했습니다",
|
||
geometryPreview: "지오메트리 미리보기",
|
||
layerPreview: "레이어 미리보기",
|
||
layerPreviewLabelNone: "— 라벨 —",
|
||
layerPreviewExportImage: "이미지 내보내기",
|
||
layerPreviewMaximize: "최대화",
|
||
layerPreviewRestore: "복원",
|
||
layerPreviewCustomBasemap: "사용자 지정 기본 지도",
|
||
layerPreviewCustomBasemapAction: "사용자 지정 기본 지도…",
|
||
layerPreviewCustomBasemapTitle: "사용자 지정 기본 지도",
|
||
layerPreviewCustomBasemapName: "이름",
|
||
layerPreviewCustomBasemapNamePlaceholder: "예: Gaode 거리",
|
||
layerPreviewCustomBasemapHint: "{z}, {x}, {y}가 포함된 XYZ 타일 URL을 입력하세요. 선택적 오버레이 URL은 라벨에 사용할 수 있습니다.",
|
||
layerPreviewCustomBasemapUrl: "타일 URL",
|
||
layerPreviewCustomBasemapOverlayUrl: "오버레이 URL",
|
||
layerPreviewCustomBasemapAttribution: "저작권 표시",
|
||
layerPreviewCustomBasemapMaxZoom: "최대 확대",
|
||
layerPreviewCustomBasemapOptional: "선택 사항",
|
||
layerPreviewCustomBasemapApply: "적용",
|
||
layerPreviewCustomBasemapInvalid: "이름과 {z}, {x}, {y}가 포함된 유효한 HTTP(S) XYZ 타일 URL을 입력하세요.",
|
||
insertRowsNotSupported: "현재 저장 대상은 행 추가를 지원하지 않습니다.",
|
||
zoomIn: "확대",
|
||
zoomOut: "축소",
|
||
fitImage: "보기에 맞춤",
|
||
openImage: "이미지 열기",
|
||
columnName: "컬럼",
|
||
columnType: "타입",
|
||
columnComment: "주석",
|
||
rowNumber: "행",
|
||
valueLength: "길이",
|
||
nullValue: "NULL",
|
||
emptyStringValue: "빈 문자열",
|
||
noComment: "주석 없음",
|
||
formattedJson: "서식된 JSON",
|
||
formatted: "서식됨",
|
||
formattedValue: "서식된 값",
|
||
detailSearchPlaceholder: "필드 또는 값 검색…",
|
||
detailSearchNoMatch: "일치 항목 없음",
|
||
rawValue: "원시 값",
|
||
largeValuePreviewHint: "처음 {count}자 미리보는 중. 복사에는 여전히 전체 값이 사용됩니다.",
|
||
largeValueRowUnavailable: "데이터베이스에서 행을 찾을 수 없습니다. 미리보기 값을 사용하지 않고 작업을 취소했습니다.",
|
||
largeValueColumnUnavailable: "큰 값에 해당하는 원본 열을 찾을 수 없습니다.",
|
||
largeValueLoadFailed: "큰 필드의 전체 값을 불러오지 못했습니다.",
|
||
largeValueNeedsStableKey: "이 테이블에는 사용할 수 있는 기본 키가 없어 큰 필드의 전체 값을 안전하게 불러올 수 없습니다. 작업을 취소했습니다.",
|
||
largeValueLoadFailedWithMessage: "큰 필드의 전체 값을 불러오지 못했습니다: {message}",
|
||
largeValueLocalSortUnavailable: "이 열에는 큰 값 미리보기가 포함되어 있어 미리보기 내용으로 현재 페이지를 정렬할 수 없습니다. 데이터베이스 정렬을 사용하세요.",
|
||
copyValue: "값 복사",
|
||
downloadBinaryValue: "값 다운로드",
|
||
binaryImportTooLarge: "파일이 너무 큽니다({size}, 상한 {limit}). 큰 파일을 단일 셀에 가져오는 것은 지원되지 않습니다.",
|
||
downloadSaved: "{path}에 저장됨",
|
||
downloadStarted: "다운로드 시작됨: {fileName}",
|
||
binaryDownload: {
|
||
binary: "원시 바이너리",
|
||
utf8: "디코딩된 텍스트 (UTF-8)",
|
||
gbk: "디코딩된 텍스트 (GBK)",
|
||
},
|
||
copyRowTsv: "행 복사 (TSV)",
|
||
copyColumnValues: "컬럼 복사 (JSON)",
|
||
copyColumnTsv: "컬럼 복사 (TSV)",
|
||
editValue: "값 편집",
|
||
formatJson: "JSON 서식",
|
||
compactJson: "JSON 압축",
|
||
compareJson: "비교",
|
||
valueDiffTitle: "{column} JSON 차이",
|
||
valueDiffFormat: "비교 형식",
|
||
valueDiffRaw: "원본",
|
||
valueDiffOriginal: "원래 값",
|
||
valueDiffCurrent: "현재 값",
|
||
copyOriginalValue: "원래 값 복사",
|
||
copyCurrentValue: "현재 값 복사",
|
||
cellValueCopied: "셀 값을 복사했습니다",
|
||
valueDiffInvalidJson: "JSON이 올바르지 않아 원본 값을 표시합니다: {message}",
|
||
valueDiffTooLarge: "값이 {limit}자를 초과하여 원본 값을 표시합니다.",
|
||
formattedJsonEditWarning: "서식된 JSON을 편집하고 있습니다. 저장하면 JSON으로 기록되어 원래 서식이 변경될 수 있습니다.",
|
||
setNull: "NULL 설정",
|
||
restoreOriginalValue: "원래대로 복원",
|
||
copyColumnName: "컬럼 이름 복사",
|
||
columnDragChipMany: "{names} (총 {count}개)",
|
||
copyAlterColumnSql: "SQL ALTER로 복사",
|
||
alterSqlCopied: "SQL ALTER를 클립보드에 복사했습니다",
|
||
alterSqlCopiedWithWarnings: "SQL ALTER를 클립보드에 복사했습니다 (경고 {count}개)",
|
||
noAlterSqlAvailable: "이 컬럼에 사용 가능한 ALTER SQL이 없습니다",
|
||
copyAlterSqlFailed: "복사 실패: {message}",
|
||
copySqlCondition: "SQL 조건 복사",
|
||
transpose: "행 전치",
|
||
transposeMultiRowToggle: "다중 행",
|
||
transposeSingleRow: "현재 행",
|
||
transposeMultiRow: "다중 행",
|
||
transposeMultiRowHint: "활성화하면 전치 보기에 여러 행을 표시합니다. 비활성화하면 현재 행만 표시합니다.",
|
||
rowsPerPageShort: "행",
|
||
columnDetails: "컬럼 상세",
|
||
tableInfo: "테이블 정보",
|
||
pinTableInfo: "테이블 정보 패널 고정",
|
||
unpinTableInfo: "테이블 정보 패널 고정 해제",
|
||
tableInfoColumns: "컬럼",
|
||
tableInfoIndexes: "인덱스",
|
||
columnPrimaryIndex: "기본 키 인덱스",
|
||
columnUniqueIndex: "고유 인덱스",
|
||
columnRegularIndex: "일반 인덱스",
|
||
tableInfoForeignKeys: "외래 키",
|
||
foreignKeyNavigate: "{table}(으)로 이동",
|
||
openUrl: "브라우저에서 URL 열기",
|
||
tableInfoConstraints: "제약 조건",
|
||
tableInfoConstraintDisabled: "비활성화됨",
|
||
tableInfoConstraintNotValidated: "검증 안 됨",
|
||
tableInfoTriggers: "트리거",
|
||
tableInfoNullable: "NULL 허용",
|
||
tableInfoEmpty: "메타데이터 없음",
|
||
tableInfoSearch: "검색...",
|
||
tableOwner: "소유자",
|
||
tableOwnerUnavailable: "사용할 수 없음",
|
||
tableInfoNoResults: "결과 없음",
|
||
goToColumn: "컬럼으로 이동",
|
||
columnWidth: "컬럼 너비",
|
||
columnWidthCompact: "좁게",
|
||
columnWidthStandard: "표준",
|
||
columnWidthComfortable: "넓게",
|
||
searchColumn: "컬럼/주석 검색...",
|
||
noColumnsFound: "컬럼이 없습니다",
|
||
queryError: "쿼리 오류",
|
||
saveErrorTitle: "변경사항 저장 실패",
|
||
dataUnavailable: "테이블 데이터를 다시 불러와야 합니다.",
|
||
viewSnapshotSelectionNotRestored: "이전 보기 위치는 복원했지만 선택 범위가 너무 커서 복원하지 못했습니다.",
|
||
cachedResultUnavailable: "캐시된 결과가 없거나 호환되지 않습니다.",
|
||
reexecuteQuery: "쿼리 다시 실행",
|
||
dataUnavailableHintPrefix: "",
|
||
dataUnavailableHintSuffix: "을(를) 누르거나 아래 새로고침을 클릭하여 다시 불러오세요.",
|
||
refresh: "새로고침",
|
||
undoChange: "실행 취소",
|
||
redoChange: "다시 실행",
|
||
commit: "커밋",
|
||
rollback: "롤백",
|
||
transactionSaveHint: "보류 중인 {count}개 변경을 트랜잭션으로 커밋합니다.",
|
||
nonTransactionalSaveHint: "보류 중인 {count}개 변경을 하나씩 저장합니다. 하나가 실패해도 앞선 성공한 변경은 롤백되지 않습니다.",
|
||
keylessEditWarning: "기본 키 없음",
|
||
keylessEditWarningHint: "이 테이블에는 기본 키가 없습니다. 수정과 삭제는 WHERE 절에 모든 원래 행 값을 사용하며, 정확히 중복된 행이 함께 영향을 받을 수 있습니다.",
|
||
queryEditReadOnly: "읽기 전용 결과",
|
||
queryEditUnsupported: {
|
||
"not-select": "SELECT 쿼리 결과만 직접 편집할 수 있습니다.",
|
||
cte: "WITH/CTE가 있는 쿼리는 아직 편집할 수 없습니다. 단순한 단일 테이블 SELECT를 사용하세요.",
|
||
"set-operation": "UNION, INTERSECT 또는 EXCEPT 결과는 소스 행에 안전하게 다시 매핑할 수 없습니다.",
|
||
aggregation: "DISTINCT, GROUP BY, HAVING 및 집계 결과는 직접 편집할 수 없습니다.",
|
||
"external-source": "외부 파일과 테이블 함수 결과는 직접 쓰기할 수 없습니다. 편집 전에 데이터베이스 테이블로 가져오세요.",
|
||
"complex-source": "DBX가 이 결과에 대해 정확히 하나의 안전한 쓰기 대상 테이블을 식별할 수 없습니다.",
|
||
"computed-columns": "계산된 표현식이나 함수 결과는 쓰기할 수 없습니다. 원시 컬럼 이름을 선택하세요.",
|
||
"no-table": "편집 가능한 소스 테이블이 감지되지 않았습니다.",
|
||
"no-primary-key": "대상 테이블에 기본 키가 없어 행을 안전하게 수정하거나 삭제할 수 없습니다.",
|
||
"primary-key-not-returned": "결과에 원시 기본 키 컬럼이 없습니다. 원래 컬럼 이름으로 포함하세요.",
|
||
"aliased-columns": "결과 컬럼이 별칭이나 표현식을 사용합니다. 원래 이름으로 편집 가능한 컬럼을 선택하세요.",
|
||
"metadata-unavailable": "DBX가 테이블 메타데이터를 불러올 수 없어 결과 편집이 비활성화되었습니다.",
|
||
},
|
||
sortUnsupported: "이 SQL은 전체 결과 정렬을 지원하지 않습니다. 단일 SELECT 쿼리로 다시 시도하세요.",
|
||
truncatedHint: "{count}행 로드 후 결과가 잘렸습니다. 로드된 데이터를 탐색하려면 푸터 페이지 매김을 사용하세요. 전체 결과를 내보내면 데이터베이스 쿼리를 다시 실행합니다.",
|
||
victoriaMetricsTruncatedHint: "결과가 로드 한도를 초과하여 처음 {count}행만 로드했습니다. 페이지당 행 수는 로드된 데이터만 나눠 표시합니다. 전체 결과를 가져오려면 시간 범위를 줄이거나 필터를 추가하세요.",
|
||
xlsxExportTitle: "내보내기 옵션",
|
||
xlsxFilterPrompt: "내보낸 Excel에 필터를 포함할지 선택하십시오:",
|
||
xlsxIncludeAutoFilter: "필터 포함",
|
||
},
|
||
exportProgress: {
|
||
streamingUnsupported: "이 쿼리는 스트리밍 내보내기를 지원하지 않습니다. 쿼리를 단순화하거나 지원되는 드라이버를 사용하세요.",
|
||
agentSessionMissing: "스트리밍 내보내기에는 결과 집합 세션이 필요하지, 이 드라이버는 session_id를 반환하지 않았습니다.",
|
||
title: "테이블 데이터 내보내는 중",
|
||
fetching: "데이터베이스에서 데이터를 가져오는 중...",
|
||
writing: "파일에 쓰는 중...",
|
||
done: "내보내기 완료!",
|
||
error: "내보내기 실패",
|
||
cancelled: "내보내기가 취소되었습니다.",
|
||
rowsCount: "{exported} / {total}행",
|
||
rowsExported: "{count}행 내보냄",
|
||
rowsShort: "행",
|
||
cancel: "취소",
|
||
minimize: "백그라운드로 최소화",
|
||
openFolder: "포함된 폴더 열기",
|
||
openFolderFailed: "폴더를 여는 데 실패했습니다: {message}",
|
||
close: "닫기",
|
||
tooltip: "백그라운드 작업",
|
||
failedTooltip: "백그라운드 작업 {count}개 실패",
|
||
popoverTitle: "백그라운드 작업",
|
||
noTasks: "백그라운드 작업이 없습니다",
|
||
clearFinished: "완료된 작업 지우기",
|
||
showMore: "{count}개 더 보기",
|
||
showLess: "줄여서 보기",
|
||
delete: "제거",
|
||
databaseExportTitle: "데이터베이스 내보내기: {name}",
|
||
databaseBackupTitle: "데이터베이스 백업: {name}",
|
||
sqlFileTitle: "SQL 파일: {name}",
|
||
dataTransferTitle: "데이터 이전: {name}",
|
||
objectsCount: "{current} / {total} 객체",
|
||
tablesCount: "{current} / {total} 테이블",
|
||
statementsCount: "{done}개 성공, {failed}개 실패",
|
||
elapsed: "경과: {duration}",
|
||
showFailureDetails: "실패 상세 ({count})",
|
||
hideFailureDetails: "실패 상세 숨기기",
|
||
failureDetailTruncated: "오류 상세가 잘렸습니다",
|
||
failureDetailsOmitted: "추가 실패 상세 {count}개가 표시되지 않았습니다",
|
||
copyFailureDetail: "실패 상세 복사",
|
||
failureDetailCopied: "실패 상세를 복사했습니다",
|
||
failureDetailCopyFailed: "실패 상세를 복사하지 못했습니다: {message}",
|
||
multiDbExecutionTitle: "다중 데이터베이스 실행: {name}",
|
||
multiDbTargets: "대상 {completed}/{total}, 성공 {success}, 실패 {failed}",
|
||
openTask: "작업 열기",
|
||
},
|
||
welcome: {
|
||
title: "데이터베이스 워크스페이스",
|
||
subtitle: "스키마를 탐색하려면 왼쪽에서 연결을 선택하거나, 쿼리 탭을 직접 여세요.",
|
||
connections: "연결",
|
||
connected: "연결됨",
|
||
databaseTypes: "데이터베이스 유형",
|
||
quickConnections: "빠른 시작",
|
||
quickConnectionsHint: "연결을 클릭하여 쿼리 탭을 여세요.",
|
||
shortcuts: "단축키",
|
||
shortcutsHint: "여기서 다음 작업을 시작하세요.",
|
||
sqlHistory: "쿼리 기록",
|
||
sqlHistoryEmpty: "아직 SQL 라이브러리 기록이 없습니다",
|
||
sqlHistoryOpenCount: "{count}회 열림",
|
||
unknownConnection: "알 수 없는 연결",
|
||
tip: "왼쪽에서 연결을 펼친 후 데이터베이스나 테이블을 우클릭하여 더 많은 작업을 수행할 수도 있습니다.",
|
||
tipSidebar: "데이터를 보려면 왼쪽의 테이블을 클릭하세요",
|
||
tipExecute: "쿼리를 실행하려면",
|
||
fileOpened: "{name}을(를) 열었습니다",
|
||
fileOpenFailed: "{name}을(를) 열지 못했습니다: {message}",
|
||
mcpTitle: "AI 에이전트 연동",
|
||
mcpDescription: "내장된 AI 어시스턴트 외에도 Claude Code, Cursor 등의 코딩 에이전트를 MCP로 연결하여 데이터베이스를 쿼리할 수 있습니다.",
|
||
mcpLearnMore: "더 알아보기",
|
||
},
|
||
backendErrors: {
|
||
jdbc: {
|
||
connectionFailed: "작업 시작 전에 데이터베이스 연결에 실패했습니다(단계: {stage}).",
|
||
connectionInterrupted: "작업 중 데이터베이스 연결이 중단되었습니다(단계: {stage}).",
|
||
operationTimedOut: "데이터베이스 작업 시간이 초과되었습니다(단계: {stage}).",
|
||
operationCanceled: "데이터베이스 작업이 취소되었습니다(단계: {stage}).",
|
||
busyRetryLater: "데이터베이스 Agent가 사용 중입니다. 나중에 다시 시도하세요(단계: {stage}).",
|
||
runtimeReplaced: "데이터베이스 Agent 런타임이 교체되었습니다(단계: {stage}).",
|
||
sqlFailed: "데이터베이스에서 SQL 오류를 반환했습니다(단계: {stage}).",
|
||
protocolFailed: "데이터베이스 Agent 프로토콜에 실패했습니다.",
|
||
contractInvalid: "데이터베이스 Agent가 잘못된 오류 계약을 반환했습니다.",
|
||
legacyFailure: "데이터베이스 Agent가 분류되지 않은 오류를 반환했습니다.",
|
||
},
|
||
transaction: {
|
||
sessionExpired: "수동 트랜잭션이 {timeoutSecs}초 동안 활동이 없어 만료되고 롤백되었습니다. 새 트랜잭션을 자동으로 시작합니다.",
|
||
},
|
||
legacy: "백엔드에서 오류를 반환했습니다.",
|
||
unknown: "예상하지 못한 백엔드 오류가 발생했습니다.",
|
||
},
|
||
common: {
|
||
fileNotFound: "파일이 존재하지 않습니다: {path}",
|
||
language: "언어",
|
||
loading: "불러오는 중...",
|
||
stopping: "중지하는 중...",
|
||
close: "닫기",
|
||
cancel: "취소",
|
||
confirm: "확인",
|
||
save: "저장",
|
||
clear: "지우기",
|
||
copy: "복사",
|
||
import: "가져오기",
|
||
remove: "제거",
|
||
retry: "다시 시도",
|
||
refresh: "새로고침",
|
||
more: "더보기",
|
||
decrease: "감소",
|
||
increase: "증가",
|
||
showPassword: "비밀번호 표시",
|
||
hidePassword: "비밀번호 숨기기",
|
||
done: "완료",
|
||
connection: "연결",
|
||
database: "데이터베이스",
|
||
table: "테이블",
|
||
view: "뷰",
|
||
materializedView: "구체화된 뷰",
|
||
procedure: "프로시저",
|
||
function: "함수",
|
||
sequence: "시퀀스",
|
||
package: "패키지",
|
||
packageBody: "패키지 본문",
|
||
noResults: "결과 없음",
|
||
edit: "편집",
|
||
delete: "삭제",
|
||
disabled: "비활성화",
|
||
back: "뒤로",
|
||
action: "작업",
|
||
actions: "작업",
|
||
},
|
||
dateTimePicker: {
|
||
open: "날짜 및 시간 선택기 열기",
|
||
inputLabel: "날짜 및 시간",
|
||
inputPlaceholder: "YYYY-MM-DD HH:mm:ss",
|
||
previousMonth: "이전 달",
|
||
nextMonth: "다음 달",
|
||
calendarLabel: "달력",
|
||
timeLabel: "시간",
|
||
hour: "시",
|
||
minute: "분",
|
||
second: "초",
|
||
cancel: "취소",
|
||
apply: "적용",
|
||
invalidDateTime: "올바른 날짜와 시간을 입력하세요",
|
||
outOfRange: "날짜와 시간이 허용 범위를 벗어납니다",
|
||
},
|
||
quickOpen: {
|
||
placeholder: "연결, 데이터베이스, 테이블, SQL 파일 및 다른 객체 검색...",
|
||
emptyPlaceholder: "검색하려면 입력을 시작하세요",
|
||
noResults: "결과를 찾을 수 없습니다",
|
||
results: "결과",
|
||
navigate: "이동",
|
||
select: "선택",
|
||
close: "닫기",
|
||
sqlFile: "SQL 파일",
|
||
sqlLibraryFile: "SQL 라이브러리",
|
||
},
|
||
explain: {
|
||
title: "실행 계획",
|
||
standardTable: "표",
|
||
tree: "트리",
|
||
summary: "요약",
|
||
running: "실행 계획을 읽는 중...",
|
||
empty: "실행 계획이 없습니다",
|
||
nodeCount: "{count}개 노드",
|
||
node: "노드",
|
||
relation: "테이블",
|
||
index: "인덱스",
|
||
cost: "비용",
|
||
rows: "행",
|
||
details: "상세",
|
||
canvas: "캔버스",
|
||
costShare: "비용 비율",
|
||
estRows: "예상 행",
|
||
actualRows: "실제 행",
|
||
zoomIn: "확대",
|
||
zoomOut: "축소",
|
||
zoomFit: "맞춤",
|
||
legendHeat: "색상 = 전체 비용 대비 비율",
|
||
legendEdge: "선 굵기 = 행 수",
|
||
inspectorEmpty: "노드를 선택하세요",
|
||
catResult: "결과",
|
||
catSort: "정렬",
|
||
catJoin: "조인",
|
||
catTscan: "테이블 스캔",
|
||
catIscan: "인덱스 스캔",
|
||
catLookup: "행 조회",
|
||
catMat: "구체화",
|
||
catAgg: "집계",
|
||
catXchg: "병렬 처리",
|
||
catMod: "변경",
|
||
catOther: "기타",
|
||
unsupported: "이 데이터베이스에서는 아직 실행 계획을 지원하지 않습니다",
|
||
emptySql: "실행 계획을 볼 SQL이 없습니다",
|
||
unsafe: "이 첫 번째 버전은 SELECT / WITH / TABLE / VALUES 구문만 지원합니다",
|
||
},
|
||
profile: {
|
||
title: "프로파일러",
|
||
emptyShards: "샤드 프로파일 데이터가 없습니다",
|
||
emptyProfile: '이 응답에 `profile` 섹션이 없습니다. 검색 본문에 "profile": true를 추가하고 다시 실행하세요.',
|
||
collapseAll: "모두 접기",
|
||
expandAll: "모두 펼치기",
|
||
selfTime: "자체",
|
||
totalTime: "전체",
|
||
breakdown: "단계",
|
||
criticalPath: "임계 경로",
|
||
criticalPathTag: "중요",
|
||
shard: "샤드",
|
||
searches: "회 검색",
|
||
collapsedProtection: "큰 프로파일: 깊은 노드는 접힌 상태로 시작합니다 ({nodes}개 노드)",
|
||
legendSelfTime: "자체 시간은 하위 노드를 제외합니다. 막대는 샤드 전체 쿼리 시간에서 차지하는 비율을 보여줍니다.",
|
||
},
|
||
lineage: {
|
||
title: "필드 계보",
|
||
open: "필드 계보 보기",
|
||
loading: "메타데이터 읽는 중 {done}/{total}",
|
||
empty: "관련 계보를 찾을 수 없습니다",
|
||
noFiltered: "현재 필터와 일치하는 결과가 없습니다",
|
||
targetField: "현재 필드",
|
||
searchPlaceholder: "테이블, 필드, 뷰 또는 SQL 조각 검색...",
|
||
showing: "{shown}/{total}개 결과 표시 중",
|
||
all: "전체",
|
||
certain: "확실",
|
||
likely: "가능성 높음",
|
||
possible: "가능",
|
||
queryHistory: "쿼리 기록",
|
||
openTable: "테이블 열기",
|
||
copy: "이름 복사",
|
||
copied: "복사했습니다",
|
||
kind: {
|
||
foreignKey: "외래 키",
|
||
viewReference: "뷰",
|
||
historyReference: "SQL 기록",
|
||
sameName: "동일 이름",
|
||
},
|
||
description: {
|
||
foreignKeyIncoming: "{target}이(가) 외래 키를 통해 현재 필드를 가리킵니다. 확인된 종속성입니다.",
|
||
foreignKeyOutgoing: "현재 필드가 외래 키를 통해 {target}을(를) 참조합니다. 확인된 종속성입니다.",
|
||
viewLikely: "뷰 정의가 대상 테이블과 필드를 모두 언급하며, 일반적으로 쿼리 종속성을 나타냅니다.",
|
||
viewPossible: "뷰 정의가 동일한 이름의 필드를 언급하지만 대상 테이블은 언급하지 않아 확인이 필요합니다.",
|
||
historyLikely: "과거 SQL 구문이 대상 테이블과 필드를 모두 언급합니다. 영향 분석 컨텍스트로 사용하세요.",
|
||
historyPossible: "과거 SQL 구문이 동일한 이름의 필드를 언급합니다. 관련이 있을 수 있지만 컨텍스트 확인이 필요합니다.",
|
||
sameName: "다른 테이블에 동일한 이름의 필드가 있습니다. 비즈니스 의미를 공유할 수 있지만 확인된 데이터베이스 종속성은 아닙니다.",
|
||
},
|
||
cancel: "취소",
|
||
refresh: "다시 분석",
|
||
},
|
||
connectionGroup: {
|
||
createGroup: "새 그룹",
|
||
group: "그룹",
|
||
groupNamePlaceholder: "그룹 이름",
|
||
selectConnection: "연결 선택",
|
||
deselectConnection: "연결 선택 해제",
|
||
selectAllConnections: "모든 연결 선택",
|
||
deselectAllConnections: "모든 연결 선택 해제",
|
||
selectedConnections: "{count}개 선택",
|
||
exitMultiSelect: "선택 종료",
|
||
renameGroup: "그룹 이름 변경",
|
||
closeConnections: "그룹 내 연결 {count}개 닫기",
|
||
deleteGroup: "그룹 삭제",
|
||
deleteSelectedGroups: "선택한 그룹 {count}개 삭제",
|
||
moveToGroup: "그룹으로 이동",
|
||
moveToNewGroup: "새 그룹으로 이동",
|
||
ungrouped: "그룹 없음",
|
||
ungroupedLabel: "기본",
|
||
newGroup: "새 그룹...",
|
||
newGroupDefault: "새 그룹",
|
||
deleteGroupConfirmTitle: "그룹 삭제",
|
||
deleteGroupConfirmMessage: '그룹 "{name}"과(와) 모든 하위 그룹을 삭제하시겠습니까? 연결도 삭제할지는 아래에서 선택하세요.',
|
||
deleteSelectedGroupsConfirmMessage: "선택한 그룹 {count}개와 모든 하위 그룹을 삭제하시겠습니까? 연결도 삭제할지는 아래에서 선택하세요.",
|
||
deleteConnectionsWithGroup: "선택한 그룹과 하위 그룹의 모든 연결도 삭제",
|
||
selectGroup: "그룹 선택",
|
||
deselectGroup: "그룹 선택 해제",
|
||
},
|
||
databaseSearch: {
|
||
title: "데이터베이스 검색",
|
||
open: "데이터베이스 검색",
|
||
keyword: "키워드",
|
||
keywordPlaceholder: "사용자 ID, 이메일, 주문 번호 입력...",
|
||
limitPerTable: "테이블당",
|
||
search: "검색",
|
||
searching: "검색 중",
|
||
stop: "중지",
|
||
hint: "현재 데이터베이스 또는 스키마의 일반 테이블을 스캔합니다. 바이너리 컬럼은 건너뛰고, 각 테이블은 한 번에 너무 많은 데이터를 불러오지 않도록 제한합니다.",
|
||
loadingTables: "테이블 목록을 읽는 중...",
|
||
progress: "테이블 {done}/{total}개 스캔",
|
||
resultCount: "{count}개 일치",
|
||
continueNextBatch: "다음 {count}개 스캔",
|
||
scanAllRemaining: "남은 {count}개 스캔",
|
||
results: "결과",
|
||
openResult: "열기",
|
||
waiting: "일치 항목을 기다리는 중...",
|
||
noResults: "아직 일치 항목이 없습니다",
|
||
errors: "일부 테이블이 실패했습니다",
|
||
},
|
||
configExport: {
|
||
passphraseTitle: "암호화 및 내보내기",
|
||
passphraseImportTitle: "파일 복호화",
|
||
passphraseExportHint: "내보내기에 연결 비밀번호를 포함하려면 암호화용 암호구를 설정하세요. 가져오려면 동일한 암호구가 필요합니다.",
|
||
passphraseImportHint: "이 파일은 암호화되어 있습니다. 암호구를 입력해 복호화한 다음 가져올 연결을 선택하세요.",
|
||
passphrase: "암호구",
|
||
passphraseConfirm: "암호구 확인",
|
||
passphrasePlaceholder: "암호구 입력",
|
||
passphraseConfirmPlaceholder: "암호구 다시 입력",
|
||
passphraseRequired: "암호구는 필수입니다",
|
||
passphraseMismatch: "암호구가 일치하지 않습니다",
|
||
passphraseTooShort: "암호구는 최소 4자 이상이어야 합니다",
|
||
exportEncrypted: "암호화하여 내보내기",
|
||
exportUnencrypted: "암호화하지 않고 내보내기",
|
||
unencryptedWarningTitle: "암호화하지 않고 내보내시겠습니까?",
|
||
unencryptedWarningDescription: "암호화되지 않은 구성 파일에는 데이터베이스 비밀번호, SSH Tunnel 자격 증명 및 기타 민감한 정보가 포함될 수 있습니다. 파일에 접근할 수 있는 사람은 이 자격 증명을 읽을 수 있습니다. 신뢰할 수 있는 환경에서 임시 마이그레이션을 할 때만 사용하세요.",
|
||
confirmUnencryptedExport: "암호화하지 않고 내보내기",
|
||
decryptImport: "복호화",
|
||
wrongPassphrase: "암호구가 잘못되었거나 파일이 손상되었습니다",
|
||
cryptoUnavailable: "이 브라우저 환경에서는 암호화된 설정 가져오기를 사용할 수 없습니다. HTTPS, localhost 또는 DBX 데스크톱을 사용하세요.",
|
||
exportFailed: "연결을 내보내지 못했습니다",
|
||
exportSuccess: "연결을 성공적으로 내보냈습니다",
|
||
importSuccess: "연결 {count}개를 가져왔습니다",
|
||
importNavicatSuccess: "Navicat 연결 {count}개를 가져왔습니다. 테스트하기 전에 비밀번호가 비어 있는 연결의 비밀번호를 입력하세요.",
|
||
importDatagripSuccess: "DataGrip 연결 {count}개를 가져왔으며, macOS 키체인에서 비밀번호 {filled}개를 채웠습니다.",
|
||
importDbeaverSuccess: "DBeaver 연결 {count}개를 가져왔습니다. 테스트하기 전에 비밀번호가 비어 있는 연결의 비밀번호를 입력하세요.",
|
||
importNone: "가져올 새 연결이 없습니다",
|
||
importLayoutConfirm: "가져온 파일에 연결 그룹이 포함되어 있습니다. 적용하시겠습니까?",
|
||
importLayoutTitle: "그룹 가져오기",
|
||
importLayoutApply: "적용",
|
||
selectExportTitle: "내보낼 연결 선택",
|
||
selectImportTitle: "가져올 연결 선택",
|
||
selectAll: "모두 선택",
|
||
deselectAll: "모두 해제",
|
||
selectedCount: "{selected} / {total}",
|
||
next: "다음",
|
||
importSelected: "{count}개 가져오기",
|
||
noConnections: "선택할 연결이 없습니다",
|
||
},
|
||
ai: {
|
||
placeholder: "자연어로 쿼리를 설명하세요...",
|
||
settings: "AI 설정",
|
||
noConfig: "AI가 구성되지 않았습니다. 설정 > AI에서 AI 공급자를 설정하세요.",
|
||
provider: "공급자",
|
||
providerCustom: "사용자 지정",
|
||
builtinProviders: "내장 지원",
|
||
partnerProviders: "우수 스폰서",
|
||
jalapenoSponsored: "$1 무료 크레딧",
|
||
jalapenoDescription: "🎉 최고의 팀들이 사용하는 엔터프라이즈급 AI를 이제 만나보세요! 최첨단 모델을 50% 할인으로 바로 체험하고, 충전할수록 더 많은 보너스를 받으세요!",
|
||
hualongDescription: "🐉 헤비 AI 개발자를 위한 공식 직결 릴레이! Codex/Claude 시리즈 100% 공식 소스, 토큰 단위 명세 검증, 기업 계약 및 인보이스 지원. \n🎉프로모 코드 DBX&HUALONG 로 가입하면 $1 크레딧 증정!",
|
||
visitPartner: "파트너 웹사이트 방문",
|
||
getApiKey: "API 키 받기",
|
||
providerStatusActive: "활성",
|
||
providerStatusConfigured: "구성됨",
|
||
switchProvider: "공급자 전환",
|
||
model: "모델",
|
||
defaultModel: "기본 모델",
|
||
browseModels: "모델 찾아보기",
|
||
refreshModels: "모델 새로고침",
|
||
loadingModels: "모델을 불러오는 중...",
|
||
modelLoadFailed: "모델을 불러오는 데 실패했습니다",
|
||
retry: "다시 시도",
|
||
searchModels: "모델 검색",
|
||
noModels: "불러온 모델이 없습니다",
|
||
noModelMatch: "일치하는 모델이 없습니다",
|
||
selectModel: "모델 선택",
|
||
noModel: "구성된 모델이 없습니다",
|
||
manualModel: "모델 ID 수동 입력",
|
||
manualModelPlaceholder: "모델 ID",
|
||
effort: "노력도",
|
||
providerDefault: "공급자 기본값",
|
||
loadingEffort: "노력도 수준을 불러오는 중...",
|
||
effortLoadFailed: "노력도 수준을 불러오는 데 실패했습니다",
|
||
effortEnabled: "활성화됨",
|
||
effortDisabled: "비활성화됨",
|
||
customEffortPlaceholder: "노력도 값 입력",
|
||
effortUnsupported: "이 모델은 노력도 설정을 지원하지 않습니다",
|
||
configNameEmpty: "구성 이름은 비워둘 수 없습니다",
|
||
configNameExists: "구성 이름 '{name}'이(가) 이미 존재합니다",
|
||
configList: "AI 구성 목록",
|
||
addConfig: "구성 추가",
|
||
noAiConfigs: "AI 구성이 없습니다",
|
||
setDefault: "기본으로 설정",
|
||
editConfig: "구성 편집",
|
||
configName: "구성 이름",
|
||
configNamePlaceholder: "구성 이름 입력",
|
||
modelList: "모델 목록",
|
||
modelId: "모델 ID",
|
||
modelDisplayName: "표시 이름",
|
||
add: "추가",
|
||
fetching: "가져오는 중...",
|
||
fetchModelList: "API에서 모델 가져오기",
|
||
default: "기본",
|
||
deleteConfigTitle: "구성 삭제",
|
||
deleteConfigConfirm: "이 구성을 삭제하시겠습니까?",
|
||
modelListHint: "새로고침을 클릭하여 공급자에서 모델을 불러오세요.",
|
||
modelListUnsupported: "이 공급자는 모델 목록 가져오기를 지원하지 않습니다.",
|
||
modelListEndpointRequired: "모델을 불러오기 전에 엔드포인트를 입력하세요.",
|
||
modelListApiKeyRequired: "모델을 불러오기 전에 API 키를 입력하세요.",
|
||
run: "실행",
|
||
readingSchema: "스키마를 읽는 중",
|
||
noConnection: "이 탭에 사용할 수 있는 연결이 없습니다",
|
||
noSql: "처리할 SQL이 없습니다",
|
||
sqlPreview: "SQL 미리보기",
|
||
copySql: "SQL 복사",
|
||
copyCode: "코드 복사",
|
||
executeSql: "SQL 실행",
|
||
tempRunSql: "편집기를 수정하지 않고 실행",
|
||
copyAll: "모두 복사",
|
||
copyMessage: "메시지 복사",
|
||
copied: "복사했습니다",
|
||
copyTestResult: "테스트 결과 복사",
|
||
testErrorAuth: "인증 또는 접근에 실패했습니다. API 키, 프로젝트 권한 및 API 가용성을 확인하세요.",
|
||
testErrorModelNotFound: "모델을 사용할 수 없습니다. 모델 ID와 계정 접근 권한을 확인하세요.",
|
||
testErrorRateLimit: "요청 속도 제한이나 할당량을 초과했습니다. 나중에 다시 시도하거나 계정 할당량을 확인하세요.",
|
||
testErrorTimeout: "요청 시간이 초과되었습니다. 네트워크, 프록시 및 엔드포인트를 확인하세요.",
|
||
testErrorTokenLimit: "출력 토큰 한도가 소진되어 표시되는 텍스트가 생성되지 않았습니다.",
|
||
testErrorSafety: "Gemini가 안전 정책에 따라 프롬프트나 응답을 차단했습니다.",
|
||
testErrorEmptyResponse: "서비스나 프록시가 표시되는 텍스트를 반환하지 않고 스트림을 닫았습니다.",
|
||
testErrorNetwork: "네트워크 연결에 실패했습니다. 엔드포인트와 프록시를 확인하세요.",
|
||
testErrorUnknown: "분류되지 않은 이유로 테스트가 실패했습니다.",
|
||
replace: "편집기 교체",
|
||
append: "편집기에 추가",
|
||
apply: "편집기에 적용",
|
||
clear: "채팅 지우기",
|
||
maximize: "최대화",
|
||
restore: "복원",
|
||
welcome: "쿼리할 내용을 말씀해 주세요. SQL을 작성해 드릴게요",
|
||
requestFailed: "AI 요청 실패",
|
||
requestCancelled: "AI 요청이 취소되었습니다",
|
||
backgroundRunCompleted: "AI 응답이 백그라운드에서 완료되었습니다",
|
||
backgroundRunNeedsConfirmation: "계속하려면 AI 확인이 필요합니다",
|
||
recoveredDraftBanner: "재시작 전에 대기열에 있던 요청이 복구되었습니다",
|
||
recoveredDraftHint: "편집 후 다시 보내거나 삭제할 수 있습니다.",
|
||
discardDraft: "초안 삭제",
|
||
runStatusRunning: "실행 중",
|
||
runStatusWaitingToStart: "시작 대기 중",
|
||
runStatusAwaitingConfirmation: "확인 대기 중",
|
||
runStatusPendingDraft: "전송 대기 입력",
|
||
runStatusCompleted: "완료",
|
||
runStatusFailed: "실패",
|
||
runStatusInterrupted: "중단됨",
|
||
runStatusCancelled: "취소됨",
|
||
runUnread: "이 대화에 새 업데이트가 있습니다",
|
||
closeWithRunsTitle: "AI 작업이 아직 실행 중입니다",
|
||
closeWithRunsDescription: "DBX를 종료하면 실행 중이거나 대기 중인 AI 작업 {count}개가 중단됩니다. 이 대화 상자를 닫고 완료될 때까지 기다릴 수도 있습니다.",
|
||
closeWithRunsQuit: "종료하고 중단",
|
||
queueSend: "보내기 대기열에 추가",
|
||
queueSendHint: "이 대화에는 아직 실행 중인 작업이 있어 메시지가 완료 후 전송됩니다",
|
||
inputQueued: "현재 작업 완료 후 보내도록 메시지가 대기열에 추가되었습니다",
|
||
queuedInputWaiting: "대기 중 — {text}",
|
||
queuedInputPending: "전송 대기 중 — {text}",
|
||
sendQueuedInput: "대기 메시지 보내기",
|
||
queuedInputEdit: "대기 메시지 편집",
|
||
queuedInputRemove: "대기 메시지 제거",
|
||
rowQueuedInput: "대기 중인 입력",
|
||
retryRound: "이번 라운드 다시 시도",
|
||
deleteConversation: "대화 삭제",
|
||
deleteActiveConversationTitle: "대화에 활성 작업이 있습니다",
|
||
deleteActiveConversationDescription: "이 대화에는 아직 실행 중이거나 대기 중인 작업이 있습니다. 작업을 취소하고 대화를 삭제할까요, 아니면 유지할까요?",
|
||
cancelTaskAndDelete: "작업 취소하고 대화 삭제",
|
||
keepConversation: "대화 유지",
|
||
awayUpdatesDivider: "자리를 비운 동안의 업데이트",
|
||
jumpToLatest: "최신으로 이동",
|
||
openPanel: "패널 열기",
|
||
runRowPhaseTool: "{tool} 실행 중",
|
||
runRowPhaseThinking: "분석 중…",
|
||
toolbarAwaitingConfirmation: "확인을 기다리는 AI 작업 {count}개",
|
||
newChat: "새 채팅",
|
||
thinking: "생각하는 중...",
|
||
reasoningProcess: "사고 과정",
|
||
chars: "자",
|
||
stopGenerating: "생성 중지",
|
||
scrollToBottom: "맨 아래로",
|
||
csvAttachmentSelect: "CSV 첨부",
|
||
csvAttachmentInvalidType: "CSV 파일을 선택하세요.",
|
||
csvAttachmentEmpty: "CSV 파일이 비어 있습니다.",
|
||
csvAttachmentReadFailed: "CSV 파일을 읽을 수 없습니다.",
|
||
csvAttachmentTruncated: "AI에 전송하기 전에 CSV 내용이 잘렸습니다.",
|
||
attachmentSelect: "이미지 또는 텍스트 파일 첨부",
|
||
attachmentSelectHint: "이미지 또는 텍스트 파일을 첨부할 수 있습니다. 이미지는 최대 4개(총 12MB), 텍스트 파일은 최대 8개(총 32,000자)입니다.",
|
||
attachmentDropHint: "파일을 놓아 첨부",
|
||
attachmentInvalidType: "PNG, JPEG, GIF 또는 WebP 이미지를 선택하세요.",
|
||
attachmentReadFailed: "첨부 파일을 읽을 수 없습니다.",
|
||
attachmentImageTooLarge: "이미지는 5 MB 이하여야 합니다.",
|
||
attachmentImageLimit: "한 번에 최대 4장의 이미지를 첨부할 수 있습니다.",
|
||
attachmentImageTotalLimit: "첨부 이미지의 총 크기는 12MB를 초과할 수 없습니다.",
|
||
attachmentTextLimit: "한 번에 텍스트 파일을 최대 8개까지 첨부할 수 있습니다.",
|
||
attachmentTextTotalLimit: "첨부 텍스트는 총 32,000자를 초과할 수 없습니다.",
|
||
attachmentFileTooLarge: "드롭한 파일은 5MB 이하여야 합니다.",
|
||
attachmentTruncatedStatus: "잘림",
|
||
attachmentEncoding: "텍스트 인코딩",
|
||
attachmentEncodingReadFailed: "선택한 인코딩으로 첨부 파일을 디코딩할 수 없습니다.",
|
||
attachmentUnsupportedProvider: "이 공급자 연결은 이미지 첨부를 전송할 수 없습니다. 이미지를 제거하거나 이미지 지원 공급자를 선택하세요.",
|
||
attachmentUnsupportedFormat: "선택한 제공자는 이 이미지 형식을 지원하지 않습니다. 이미지를 제거하거나 PNG, JPEG 또는 WebP를 사용하세요.",
|
||
attachmentPreview: "첨부 파일 미리보기",
|
||
attachmentUnavailableAfterReload: "다시 로드한 후에는 콘텐츠를 사용할 수 없으며 다시 전송되지 않습니다",
|
||
attachmentUnsupportedDocument: "이 파일 형식은 아직 지원되지 않습니다. 이미지 또는 텍스트 파일을 첨부하세요.",
|
||
tableMentionEmpty: "일치하는 테이블이나 SQL 파일이 없습니다",
|
||
tableMentionPlaceholderHint: "{'@'}를 입력하여 컨텍스트용 테이블이나 SQL 파일을 멘션하세요",
|
||
tableMentionTypes: {
|
||
table: "테이블",
|
||
view: "뷰",
|
||
systemTable: "시스템 테이블",
|
||
temporaryTable: "임시 테이블",
|
||
},
|
||
modes: {
|
||
ask: "질문",
|
||
agent: "에이전트",
|
||
},
|
||
modeHints: {
|
||
ask: "SQL과 설명을 자동 실행 없이 생성",
|
||
agent: "도구를 사용해 데이터를 쿼리하고 실제 결과로 답변",
|
||
},
|
||
fixWithAi: "AI로 수정",
|
||
truncated: "컨텍스트가 잘렸습니다",
|
||
contextSummary: "{database} · 테이블 {tables}개",
|
||
autoSqlBlocked: "AI가 생성한 SQL이 자동 실행하기에는 너무 위험해 보입니다. 실행 전에 수동으로 검토하세요.",
|
||
writeSqlConfirmationRequired: "이 SQL은 데이터 또는 스키마를 변경합니다. 실행 전에 신중하게 검토하세요.",
|
||
writeSqlConfirmationQuestion: "이 SQL을 한 번 실행할까요?",
|
||
writeSqlConfirmYes: "실행 확인",
|
||
writeSqlConfirmNo: "취소",
|
||
writeSqlConfirmationReplyYes: "위에 표시된 정확한 SQL을 한 번만 실행하세요. 다시 확인하지 마세요.",
|
||
writeSqlConfirmationReplyNo: "위에 표시된 SQL을 실행하지 말고 대화를 계속하세요.",
|
||
productionWriteBlocked: "AI는 운영 데이터베이스에서 데이터 또는 스키마 변경을 실행할 수 없습니다. 이 SQL을 검토한 후 DBX에서 수동으로 실행하세요.",
|
||
proposalConfirmReplyYes: "위에서 제안한 작업을 실행하세요. 다시 확인을 요청하지 마세요.",
|
||
proposalConfirmReplyNo: "위에서 언급한 작업을 실행하지 말고 대화를 계속하세요.",
|
||
proposalConfirmYes: "예, 진행",
|
||
proposalConfirmNo: "아니오",
|
||
proposalConfirmTitle: "작업 확인이 필요합니다",
|
||
agentSteps: {
|
||
generated: "SQL 생성됨",
|
||
noSql: "SQL을 찾을 수 없음",
|
||
safe: "안전성 통과",
|
||
needsConfirm: "확인 필요",
|
||
blocked: "차단됨",
|
||
autoExecute: "실행 준비됨",
|
||
notRequested: "실행 요청되지 않음",
|
||
skipped: "실행되지 않음",
|
||
callingTool: "도구 호출 중...",
|
||
executing: "실행 중…",
|
||
toolDone: "도구 완료",
|
||
toolError: "도구 오류",
|
||
executeSafe: "안전성 검사 통과 · 실행됨",
|
||
executeBlocked: "안전성 검사로 차단됨",
|
||
contextCompacted: "컨텍스트 압축됨",
|
||
},
|
||
agentStepTitles: {
|
||
riskCheck: "위험 검사: {action} · {category} · {environment} · {reasons}",
|
||
blocked: "위험 정책에 의해 실행이 차단되었습니다. SQL을 수동으로 검토하세요.",
|
||
requiresConfirmation: "이 SQL은 실행 전에 확인이 필요합니다.",
|
||
askMode: "질문 모드는 SQL을 자동 실행하지 않습니다.",
|
||
unsupportedAction: "현재 AI 작업은 SQL을 자동 실행하지 않습니다.",
|
||
noSql: "응답에 실행 가능한 SQL 코드 블록이 포함되어 있지 않습니다.",
|
||
notRequested: "사용자가 SQL 실행을 요청하지 않았습니다.",
|
||
skipped: "이 단계는 실행되지 않았습니다.",
|
||
},
|
||
status: {
|
||
waitingModel: "모델 응답 대기 중 · 실행 {elapsed}s",
|
||
waitingModelLive: "모델 응답 대기 중",
|
||
generating: "답변 생성 중 · 실행 {elapsed}s",
|
||
generatingLive: "답변 생성 중",
|
||
runningTool: "{turn}라운드 · {tool} 실행 중 · 실행 {elapsed}s",
|
||
runningToolAction: "· 실행 중",
|
||
runningToolElapsed: "· 실행 {elapsed}s",
|
||
turnBadge: "{turn}라운드",
|
||
idle: "이 단계 완료 대기 중 · 마지막 활동 {idle}s 전",
|
||
idleLive: "이 단계 완료 대기 중",
|
||
idleWithTool: "이 단계 완료 대기 중 · 마지막 활동 {idle}s 전 · {tool} 실행 중",
|
||
longRunningHint: "예상보다 오래 걸리고 있습니다. 계속 기다리거나 중지할 수 있습니다.",
|
||
cancelling: "취소 중…",
|
||
toolLabels: {
|
||
executeQuery: "쿼리 실행",
|
||
executeSql: "SQL 실행",
|
||
listTables: "테이블 나열",
|
||
getColumns: "컬럼 가져오기",
|
||
getCurrentTime: "현재 시간 가져오기",
|
||
explainQuery: "실행 계획 설명",
|
||
getSampleData: "샘플 데이터 가져오기",
|
||
listCollections: "컬렉션 나열",
|
||
browseCollection: "컬렉션 탐색",
|
||
},
|
||
},
|
||
proxy: "프록시",
|
||
proxyEnable: "프록시를 통해 AI 요청 전송",
|
||
proxyUrl: "프록시 URL",
|
||
sslVerification: "SSL 인증서",
|
||
skipTlsVerify: "SSL 인증서 검증 건너뛰기",
|
||
skipTlsVerifyHint: "자체 서명 인증서를 사용하는 신뢰할 수 있는 엔드포인트에서만 건너뛰세요. 검증을 건너뛰면 트래픽이 가로채기에 취약해집니다.",
|
||
customHeaders: "사용자 지정 헤더",
|
||
customHeadersAdd: "헤더 추가",
|
||
customHeadersHint: "모델 검색, 연결 테스트, 채팅 및 Agent 요청에 이 헤더가 전송됩니다. 값에는 민감한 정보가 포함될 수 있습니다.",
|
||
customHeadersNamePlaceholder: "X-Tenant-ID",
|
||
customHeadersValuePlaceholder: "tenant-a",
|
||
customHeadersInvalidName: "잘못된 헤더 이름: {name}",
|
||
customHeadersInvalidValue: "잘못된 헤더 값: {name}",
|
||
customHeadersDuplicate: "중복된 헤더 이름: {name}",
|
||
customHeadersReserved: "이 헤더는 DBX에서 관리합니다: {name}",
|
||
enableThinking: "사고",
|
||
enableThinkingOn: "활성화됨",
|
||
enableThinkingOff: "비활성화됨",
|
||
enableThinkingHint: "이 옵션은 /chat/completions API와 지원되는 모델에만 적용됩니다. 비활성화하면 토큰 사용량을 크게 줄일 수 있지만, 생성 결과의 품질이 약간 떨어질 수 있습니다.",
|
||
anthropicMessagesHint: "Anthropic Messages 호환 API는 일반적으로 /v1/messages를 사용합니다.",
|
||
openAiCompatibleEndpointHint: "대부분의 OpenAI 호환 API는 /v1 경로 접두사가 필요합니다.",
|
||
contextWindow: "컨텍스트 창",
|
||
contextWindowAuto: "자동 (모델 이름에서 감지)",
|
||
contextWindowHint: "토큰. 자동 감지하려면 비워 두세요. 로컬/사용자 지정 모델은 수동으로 설정하세요.",
|
||
maxOutputTokens: "최대 출력 토큰",
|
||
maxOutputTokensAuto: "자동 (모델 기본값)",
|
||
maxOutputTokensHint: "공급자에게 전송되는 선택적 구성별 출력 토큰 제한입니다. 범위: {min}–{max}. 사고 요청은 여전히 최소 8192 토큰을 사용합니다.",
|
||
codexCliPath: "Codex CLI 경로",
|
||
codexCliPathHint: "PATH의 codex를 사용하려면 비워 두세요. codex login으로 별도로 로그인하세요.",
|
||
codexCliPathEnvError: "Codex CLI 경로에는 실행 파일 경로만 포함해야 합니다. 환경 변수는 아래에 추가하세요.",
|
||
codexCliEnv: "환경 변수",
|
||
codexCliEnvAdd: "변수 추가",
|
||
codexCliEnvHint: "Codex CLI에 전달할 선택적 변수 (예: HTTPS_PROXY, NO_PROXY, SSL_CERT_FILE, CODEX_CA_CERTIFICATE).",
|
||
codexCliEnvKeyPlaceholder: "HTTPS_PROXY",
|
||
codexCliEnvValuePlaceholder: "http://proxy:9800",
|
||
codexCliEnvInvalidName: "잘못된 환경 변수 이름: {name}",
|
||
codexCliEnvReservedName: "{name}은(는) MCP 서버용으로 DBX가 관리하며 여기서 설정할 수 없습니다.",
|
||
cliMcpRequiredTitle: "DBX MCP 서버 필요",
|
||
cliMcpRequiredDescription: "{provider}은(는) 데이터베이스 스키마와 쿼리 도구에 접근하기 위해 DBX MCP 서버를 사용합니다. AI 어시스턴트에서 이 공급자를 사용하기 전에 설치하세요.",
|
||
cliPath: "{provider} 경로",
|
||
cliPathHint: "PATH의 {command}를 사용하려면 비워 두세요. {loginCommand}로 별도로 로그인하세요.",
|
||
cliPathEnvError: "{provider} 경로에는 실행 파일 경로만 포함해야 합니다. 환경 변수는 아래에 추가하세요.",
|
||
cliEnv: "환경 변수",
|
||
cliEnvAdd: "변수 추가",
|
||
cliEnvHint: "{provider}에 전달할 선택적 변수 (예: HTTPS_PROXY, NO_PROXY, SSL_CERT_FILE).",
|
||
cliEnvKeyPlaceholder: "HTTPS_PROXY",
|
||
cliEnvValuePlaceholder: "http://proxy:9800",
|
||
cliEnvInvalidName: "잘못된 환경 변수 이름: {name}",
|
||
cliEnvReservedName: "{name}은(는) MCP 서버용으로 DBX가 관리하며 여기서 설정할 수 없습니다.",
|
||
codexMcpRequiredTitle: "DBX MCP 서버 필요",
|
||
codexMcpRequiredDescription: "Codex CLI는 데이터베이스 스키마와 쿼리 도구에 접근하기 위해 DBX MCP 서버를 사용합니다. AI 어시스턴트에서 Codex를 사용하기 전에 설치하세요.",
|
||
reasoningLevel: "추론 수준",
|
||
reasoningLevelDefault: "기본",
|
||
reasoningLevelMinimal: "최소",
|
||
reasoningLevelLow: "낮음",
|
||
reasoningLevelMedium: "중간",
|
||
reasoningLevelHigh: "높음",
|
||
reasoningLevelXhigh: "매우 높음",
|
||
reasoningLevelMax: "최대",
|
||
reasoningLevelHint: "Codex CLI model_reasoning_effort를 제어합니다. 기본값은 Codex 설정을 사용합니다.",
|
||
claudeCodeEffortHint: "사용 가능한 수준은 선택한 모델이 로컬 Claude Code CLI를 통해 보고합니다.",
|
||
claudeCodeEffortUnavailable: "선택한 모델이 노력도 설정을 보고하지 않습니다. Claude Code가 기본값을 사용합니다.",
|
||
cliErrors: {
|
||
code: "오류 코드: {code}",
|
||
details: "진단 상세:",
|
||
reportHint: "이 문제를 보고할 때 아래의 오류 코드와 진단 상세를 포함하세요.",
|
||
claudeCodeNotInstalled: "Claude Code CLI를 찾을 수 없습니다. Claude Code를 설치하거나 설정 > AI에서 실행 파일 경로를 설정하세요.",
|
||
claudeCodeCliPathInvalid: "Claude Code CLI 경로가 잘못되었습니다. Claude 실행 파일만 선택하고 환경 변수는 별도로 구성하세요.",
|
||
claudeCodeEnvInvalid: "Claude Code CLI 환경 변수 이름이 잘못되었습니다. HTTPS_PROXY 같은 이름을 사용하세요.",
|
||
claudeCodeEnvReserved: "DBX가 관리하는 MCP 환경 변수가 재정의되었습니다. 공급자 구성에서 DBX_MCP_* 변수를 제거하세요.",
|
||
claudeCodeNotAuthenticated: "Claude Code CLI가 인증되지 않았습니다. 터미널에서 `claude auth login`을 실행한 후 다시 시도하세요.",
|
||
claudeCodeMcpConfigInvalid: "Claude Code가 DBX MCP 구성을 읽거나 파싱할 수 없습니다. Claude Code CLI 버전과 실행 파일 경로를 확인하세요.",
|
||
dbxMcpMissing: "호환되는 DBX MCP 서버 설치를 찾을 수 없습니다. 설정 > MCP를 확인한 후 다시 설치하거나 업데이트하세요.",
|
||
claudeCodeMcpStartupFailed: "Claude Code가 MCP 구성을 불러왔지만 DBX MCP 서버를 시작할 수 없습니다. 설정 > MCP와 아래 진단을 확인하세요.",
|
||
claudeCodeCommandLineTooLong: "명령이 너무 길어 Windows가 Claude Code 명령을 거부했습니다. DBX를 업데이트하고 생성된 MCP 구성 파일을 사용하여 다시 시도하세요.",
|
||
claudeCodeRunFailed: "Claude Code CLI가 예기치 않게 종료되었습니다. 아래의 오류 코드와 진단을 사용하여 실패한 실행 파일이나 CLI 출력을 파악하세요.",
|
||
piAgentNotInstalled: "Pi Coding Agent를 찾을 수 없습니다. Pi를 설치하거나 설정 > AI에서 실행 파일 경로를 설정하세요.",
|
||
piAgentCliPathInvalid: "Pi Coding Agent 경로가 잘못되었습니다. Pi 실행 파일만 선택하고 환경 변수는 별도로 구성하세요.",
|
||
piAgentEnvInvalid: "Pi Coding Agent 환경 변수 이름이 잘못되었습니다. HTTPS_PROXY 같은 이름을 사용하세요.",
|
||
piAgentEnvReserved: "DBX가 관리하는 Pi 또는 MCP 환경 변수가 재정의되었습니다. 공급자 구성에서 DBX_PI_* 및 DBX_MCP_* 변수를 제거하세요.",
|
||
piAgentNotAuthenticated: "Pi Coding Agent에 인증된 모델 공급자가 없습니다. Pi로 공급자를 구성하거나 로그인한 후 다시 시도하세요.",
|
||
piAgentMcpStartupFailed: "Pi가 범위 지정된 DBX MCP 브리지를 시작할 수 없습니다. 설정 > MCP와 아래 진단을 확인하세요.",
|
||
piAgentTimeout: "Pi Coding Agent가 작업 시간 초과 전에 응답하지 않았습니다.",
|
||
piAgentProtocolError: "Pi Coding Agent가 잘못된 RPC 응답을 반환했습니다. Pi 버전과 아래 진단을 확인하세요.",
|
||
piAgentModelInvalid: "선택한 Pi 모델 식별자가 잘못되었습니다. 모델 목록을 새로고침하고 공급자/모델 항목을 선택하세요.",
|
||
piAgentRunFailed: "Pi Coding Agent가 예기치 않게 종료되었습니다. 아래의 오류 코드와 진단을 사용하여 실패한 실행 파일이나 CLI 출력을 파악하세요.",
|
||
openCodeNotInstalled: "OpenCode CLI를 찾을 수 없습니다. OpenCode를 설치하거나 설정 > AI에서 실행 파일 경로를 지정하세요.",
|
||
openCodeCliPathInvalid: "OpenCode CLI 경로가 올바르지 않습니다. OpenCode 실행 파일만 선택하고 환경 변수는 별도로 설정하세요.",
|
||
openCodeEnvInvalid: "OpenCode CLI 환경 변수 이름이 올바르지 않습니다. HTTPS_PROXY와 같은 이름을 사용하세요.",
|
||
openCodeEnvReserved: "OpenCode 또는 DBX가 관리하는 환경 변수를 덮어썼습니다. 공급자 설정에서 OPENCODE 제어 변수와 DBX_MCP_* 변수를 제거하세요.",
|
||
openCodeNotAuthenticated: "OpenCode에 인증된 모델 공급자가 없습니다. `opencode auth login`을 실행하거나 OpenCode에서 공급자를 구성한 후 다시 시도하세요.",
|
||
openCodeMcpStartupFailed: "OpenCode가 범위가 제한된 DBX MCP 서버를 시작하지 못했습니다. 설정 > MCP와 아래 진단을 확인하세요.",
|
||
openCodeTimeout: "OpenCode CLI가 제한 시간 안에 응답하지 않았습니다.",
|
||
openCodeProtocolError: "OpenCode CLI가 잘못된 JSON 이벤트 스트림을 반환했습니다. OpenCode 버전과 아래 진단을 확인하세요.",
|
||
openCodeRunFailed: "OpenCode CLI가 예기치 않게 종료되었습니다. 아래의 오류 코드와 진단을 사용하여 실패한 실행 파일이나 CLI 출력을 파악하세요.",
|
||
cursorNotInstalled: "Cursor CLI를 찾을 수 없습니다. Cursor CLI를 설치하거나 설정 > AI에서 실행 파일 경로를 지정하세요.",
|
||
cursorCliPathInvalid: "Cursor CLI 경로가 올바르지 않습니다. agent 실행 파일만 선택하고 환경 변수는 별도로 설정하세요.",
|
||
cursorEnvInvalid: "Cursor CLI 환경 변수 이름이 올바르지 않습니다. HTTPS_PROXY와 같은 이름을 사용하세요.",
|
||
cursorEnvReserved: "Cursor 또는 DBX가 관리하는 환경 변수를 덮어썼습니다. CURSOR_CONFIG_DIR, CURSOR_DATA_DIR 및 DBX_MCP_* 변수를 제거하세요.",
|
||
cursorNotAuthenticated: "Cursor CLI에 로그인되어 있지 않습니다. 터미널에서 `agent login`을 실행한 후 다시 시도하세요.",
|
||
cursorMcpStartupFailed: "Cursor가 범위가 제한된 DBX MCP 서버를 시작하지 못했습니다. 설정 > MCP와 아래 진단을 확인하세요.",
|
||
cursorTimeout: "Cursor CLI가 제한 시간 안에 응답하지 않았습니다.",
|
||
cursorProtocolError: "Cursor CLI가 잘못된 JSON 이벤트 스트림을 반환했습니다. Cursor CLI 버전과 아래 진단을 확인하세요.",
|
||
cursorRunFailed: "Cursor CLI가 예기치 않게 종료되었습니다. 아래의 오류 코드와 진단을 사용하여 실패 원인을 확인하세요.",
|
||
grokCliNotInstalled: "Grok CLI를 찾을 수 없습니다. Grok CLI를 설치하거나 설정 > AI에서 실행 파일 경로를 설정하세요.",
|
||
grokCliPathInvalid: "Grok CLI 경로가 잘못되었습니다. grok 실행 파일만 선택하고 환경 변수는 별도로 구성하세요.",
|
||
grokCliEnvInvalid: "Grok CLI 환경 변수 이름이 잘못되었습니다. HTTPS_PROXY 같은 이름을 사용하세요.",
|
||
grokCliEnvReserved: "DBX가 관리하는 MCP 환경 변수가 재정의되었습니다. 공급자 구성에서 DBX_MCP_* 변수를 제거하세요.",
|
||
grokCliNotAuthenticated: "Grok CLI가 인증되지 않았습니다. 터미널에서 `grok login`을 실행한 후 다시 시도하세요.",
|
||
grokCliMcpStartupFailed: "Grok이 MCP 구성을 불러왔지만 DBX MCP 서버를 시작할 수 없습니다. 설정 > MCP와 아래 진단을 확인하세요.",
|
||
grokCliCommandLineTooLong: "명령이 너무 길어 Windows가 Grok CLI 명령을 거부했습니다. DBX를 업데이트하고 생성된 프롬프트 파일을 사용하여 다시 시도하세요.",
|
||
grokCliRunFailed: "Grok CLI가 예기치 않게 종료되었습니다. 아래의 오류 코드와 진단을 사용하여 실패한 실행 파일이나 CLI 출력을 파악하세요.",
|
||
codeBuddyNotInstalled: "CodeBuddy Code CLI를 찾을 수 없습니다. CodeBuddy Code를 설치하거나 설정 > AI에서 실행 파일 경로를 지정하세요.",
|
||
codeBuddyCliPathInvalid: "CodeBuddy Code CLI 경로가 잘못되었습니다. codebuddy 실행 파일만 선택하고 환경 변수는 별도로 구성하세요.",
|
||
codeBuddyEnvInvalid: "CodeBuddy 환경 변수 이름이 잘못되었습니다. HTTPS_PROXY 같은 유효한 이름을 사용하세요.",
|
||
codeBuddyEnvReserved: "DBX가 관리하는 MCP 환경 변수가 재정의되었습니다. 공급자 구성에서 DBX_MCP_* 변수를 제거하세요.",
|
||
codeBuddyNotAuthenticated: "CodeBuddy Code에 로그인되어 있지 않습니다. 터미널에서 `codebuddy`를 열어 로그인한 후 다시 시도하세요.",
|
||
codeBuddyTimeout: "CodeBuddy Code CLI가 작업 제한 시간 전에 응답하지 않았습니다.",
|
||
codeBuddyMcpConfigInvalid: "CodeBuddy Code가 임시 DBX MCP 구성을 읽지 못했습니다. 아래 진단을 확인하세요.",
|
||
codeBuddyMcpStartupFailed: "CodeBuddy Code가 MCP 구성을 불러왔지만 DBX MCP Server를 시작하지 못했습니다. 설정 > MCP와 아래 진단을 확인하세요.",
|
||
codeBuddyProtocolError: "CodeBuddy Code가 잘못된 제어 응답 또는 JSON 이벤트 스트림을 반환했습니다. CodeBuddy Code 버전과 아래 진단을 확인하세요.",
|
||
codeBuddyRunFailed: "CodeBuddy Code CLI가 예기치 않게 종료되었습니다. 아래의 오류 코드와 진단을 사용하여 실패한 실행 파일이나 CLI 출력을 파악하세요.",
|
||
qoderNotInstalled: "Qoder CLI를 찾을 수 없습니다. Qoder CLI를 설치하거나 설정 > AI에서 실행 파일 경로를 지정하세요.",
|
||
qoderCliPathInvalid: "Qoder CLI 경로가 올바르지 않습니다. qodercli 실행 파일만 선택하고 환경 변수는 별도로 구성하세요.",
|
||
qoderEnvInvalid: "Qoder CLI 환경 변수 이름이 올바르지 않습니다. HTTPS_PROXY 또는 QODER_PERSONAL_ACCESS_TOKEN 같은 이름을 사용하세요.",
|
||
qoderEnvReserved: "DBX에서 관리하는 MCP 환경 변수가 재정의되었습니다. 공급자 구성에서 DBX_MCP_* 변수를 제거하세요.",
|
||
qoderNotAuthenticated: "Qoder CLI가 인증되지 않았습니다. 터미널에서 `qodercli login`을 실행하거나 QODER_PERSONAL_ACCESS_TOKEN을 구성한 후 다시 시도하세요.",
|
||
qoderTimeout: "Qoder CLI가 작업 제한 시간 내에 응답하지 않았습니다.",
|
||
qoderMcpConfigInvalid: "Qoder CLI가 임시 DBX MCP 구성을 읽을 수 없습니다. Qoder CLI 버전과 아래 진단을 확인하세요.",
|
||
qoderMcpStartupFailed: "Qoder CLI가 MCP 구성을 불러왔지만 DBX MCP Server를 시작할 수 없습니다. 설정 > MCP와 아래 진단을 확인하세요.",
|
||
qoderProtocolError: "Qoder CLI가 잘못된 JSON 이벤트 스트림을 반환했습니다. Qoder CLI 버전과 아래 진단을 확인하세요.",
|
||
qoderRunFailed: "Qoder CLI가 예기치 않게 종료되었습니다. 아래 오류 코드와 진단을 사용하여 실패한 실행 파일이나 CLI 출력을 확인하세요.",
|
||
},
|
||
actions: {
|
||
general: "일반",
|
||
generate: "SQL 생성",
|
||
explain: "SQL 설명",
|
||
optimize: "SQL 최적화",
|
||
fix: "오류 수정",
|
||
convert: "방언 변환",
|
||
sampleData: "샘플 데이터",
|
||
query: "데이터 쿼리",
|
||
exploreSchema: "스키마 검사",
|
||
executeAndExplain: "실행 및 설명",
|
||
generateNoExec: "생성 (실행 안 함)",
|
||
},
|
||
placeholders: {
|
||
general: "무엇이든 물어보세요...",
|
||
generate: "쿼리할 내용을 설명하세요. 예: 최근 7일간 사용자별 주문",
|
||
explain: "선택: 이해하고 싶은 내용 추가",
|
||
optimize: "선택: 목표 추가. 예: 전체 테이블 스캔 줄이기",
|
||
fix: "오류를 붙여넣거나 예상 결과를 설명하세요",
|
||
convert: "예: PostgreSQL / MySQL / SQL Server로 변환",
|
||
sampleData: "생성할 샘플 데이터나 테스트 구문을 설명하세요",
|
||
query: "쿼리하거나 셀 항목을 설명하세요. 예: 이번 달 지역별 주문 합계",
|
||
exploreSchema: "검사할 테이블이나 구조를 설명하세요. 예: orders의 컬럼과 인덱스",
|
||
executeAndExplain: "선택: 설명에서 집중할 내용 추가",
|
||
},
|
||
editMessage: "메시지 편집",
|
||
editResend: "다시 보내기",
|
||
editCancel: "취소",
|
||
cannotDeleteActiveConfig: "현재 활성 구성은 삭제할 수 없습니다. 먼저 다른 구성으로 전환하세요.",
|
||
globalInstructions: "전역 사용자 지정 지시",
|
||
globalInstructionsDescription: "모든 AI 대화에 자동으로 적용됩니다.",
|
||
globalInstructionsCharCount: "{count}/{max}자",
|
||
globalInstructionsSaved: "전역 지시를 저장했습니다",
|
||
globalInstructionsSave: "저장",
|
||
globalInstructionsTooLong: "전역 지시가 너무 깁니다 (최대 {max}자)",
|
||
customInstructionsLoadFailed: "사용자 지정 AI 지시를 불러오는 데 실패했습니다. 다시 시도해 주세요.",
|
||
maxAgentTurns: "에이전트 턴 제한",
|
||
maxAgentTurnsDescription: "API 에이전트 실행 중 일시 중지하고 계속할지 묻기 전의 최대 도구 호출 턴 수입니다. CLI 공급자는 자체 실행 제한을 사용합니다.",
|
||
maxAgentTurnsRange: "{min}–{max}, 기본 {default}",
|
||
maxAgentTurnsSaved: "에이전트 턴 제한을 저장했습니다",
|
||
defaultAiMode: "기본 AI 모드",
|
||
defaultAiModeDescription: "새 AI 대화를 시작할 때 사용되는 모드입니다. 현재 대화에서 모드를 전환해도 이 설정은 변경되지 않습니다.",
|
||
restoreLastConversation: "열 때 마지막 AI 대화 복원",
|
||
restoreLastConversationDescription: "사용하면 AI 어시스턴트를 열 때 빈 대화 대신 가장 최근에 업데이트된 대화를 불러옵니다.",
|
||
promptTemplates: "시나리오 프롬프트 템플릿",
|
||
promptTemplatesDescription: "AI 어시스턴트에서 하나 이상의 템플릿을 선택하여 시나리오별 규칙을 주입합니다.",
|
||
promptTemplateNew: "새 템플릿",
|
||
promptTemplateEdit: "템플릿 편집",
|
||
promptTemplateName: "템플릿 이름",
|
||
promptTemplateNamePlaceholder: "예: 프로덕션 DB 규칙",
|
||
promptTemplateContent: "템플릿 내용",
|
||
promptTemplateContentPlaceholder: "규칙이나 지시를 설명하세요...",
|
||
promptTemplateNameEmpty: "템플릿 이름은 비워둘 수 없습니다",
|
||
promptTemplateNameExists: "템플릿 이름 '{name}'이(가) 이미 존재합니다",
|
||
promptTemplateContentRequired: "템플릿 내용은 비워둘 수 없습니다",
|
||
promptTemplateDeleteTitle: "템플릿 삭제",
|
||
promptTemplateDeleteConfirm: "템플릿 '{name}'을(를) 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.",
|
||
promptTemplateTooLong: "템플릿 내용이 너무 깁니다 (최대 {max}자)",
|
||
promptTemplateNameTooLong: "템플릿 이름이 너무 깁니다 (최대 {max}자)",
|
||
promptTemplateSaved: "템플릿을 저장했습니다",
|
||
promptTemplateDeleted: "템플릿을 삭제했습니다",
|
||
promptTemplateNoTemplates: "아직 템플릿이 없습니다. 시작하려면 하나를 만드세요.",
|
||
promptTemplateManage: "템플릿 관리",
|
||
promptTemplateSavedHint: "변경 사항은 자동으로 저장됩니다.",
|
||
templateSelectorNone: "선택 안 됨",
|
||
templateSelectorButton: "템플릿",
|
||
templateSelectorLabel: "템플릿: {label}",
|
||
templateSelectorDeselectAll: "모두 선택 해제",
|
||
templateSelectorLoading: "불러오는 중...",
|
||
templateSelectorEmpty: "템플릿이 없습니다. 추가하려면 관리를 클릭하세요.",
|
||
templateSelectorTooLong: "선택한 템플릿이 전체 내용 한도를 초과합니다 ({max}자). 계속하려면 일부를 선택 해제하세요.",
|
||
templateSetDefault: "기본값으로 설정",
|
||
templateDefaultsTitle: "데이터베이스 유형별 기본값",
|
||
templateDefaultsEmpty: "아직 어떤 데이터베이스 유형의 기본값으로도 설정되지 않았습니다. 설정하면 해당 데이터베이스 연결에서 AI 패널을 열 때 자동으로 선택됩니다.",
|
||
templateDefaultBadgeTitle: "{type}의 기본 템플릿",
|
||
exportMarkdown: "Markdown으로 내보내기",
|
||
analysis: "AI 분석",
|
||
chartDownloadPng: "PNG 다운로드",
|
||
chartDownloadFailed: "차트 이미지를 다운로드하지 못했습니다",
|
||
chartData: "차트 데이터",
|
||
htmlPreviewLabel: "AI 생성 HTML 미리보기",
|
||
htmlExpandPreview: "큰 화면으로 미리보기",
|
||
htmlExpandPreviewHint: "이 미리보기는 완전한 샌드박스에서 실행되며 스크립트와 네트워크 액세스가 차단됩니다.",
|
||
htmlSaveSafe: "안전한 HTML 저장",
|
||
htmlSaveFailed: "HTML 파일 저장에 실패했습니다",
|
||
htmlCopySource: "소스 복사",
|
||
htmlCopyRiskBody: "이 HTML은 AI가 생성했습니다. DBX 외부에서 열면 스크립트가 실행되고 네트워크에 접근할 수 있습니다.",
|
||
htmlCopyRiskAccept: "그래도 복사",
|
||
htmlCopyRiskRemember: "이 세션에서 다시 묻지 않기",
|
||
htmlCopyRiskToast: "복사되었습니다. 이 AI 생성 HTML은 DBX 외부에서 열면 스크립트를 실행하거나 네트워크에 접근할 수 있습니다.",
|
||
exportConversation: "대화 내보내기",
|
||
conversationExportMarkdown: "Markdown으로 내보내기",
|
||
conversationExportHtml: "HTML로 내보내기",
|
||
conversationRoleUser: "사용자",
|
||
conversationRoleAssistant: "AI",
|
||
conversationFailedMarker: "이 응답 생성에 실패했습니다",
|
||
conversationExportEmpty: "내보낼 메시지가 없습니다",
|
||
renameConversation: "Rename conversation",
|
||
conversationRenameFailed: "Failed to rename conversation",
|
||
clearDatabaseSelection: "Clear selection",
|
||
searchDatabases: "데이터베이스 검색…",
|
||
noDatabasesFound: "데이터베이스를 찾을 수 없습니다",
|
||
},
|
||
contextMenu: {
|
||
openConnection: "연결 열기",
|
||
closeConnection: "연결 닫기",
|
||
closeSelectedConnections: "선택한 연결 {count}개 닫기",
|
||
closeDatabaseConnection: "데이터베이스 연결 닫기",
|
||
deleteConnection: "연결 삭제",
|
||
deleteSelectedConnections: "선택한 연결 {count}개 삭제",
|
||
confirmDeleteTitle: "연결 삭제",
|
||
confirmDeleteMessage: '"{name}"을(를) 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.',
|
||
confirmDeleteSelectedMessage: "선택한 연결 {count}개를 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.",
|
||
editConnection: "연결 편집",
|
||
revealDatabaseFile: "파일 관리자에서 보기",
|
||
selectVisibleDatabases: "표시할 데이터베이스 선택",
|
||
configureVisibleObjects: "표시 객체 필터",
|
||
userAdmin: "사용자 및 권한",
|
||
openUserAdmin: "사용자 및 권한 열기",
|
||
processList: "프로세스 목록",
|
||
sqlServerTrace: "활동 추적",
|
||
serverDashboard: "서버 대시보드",
|
||
damengJobAdmin: "Dameng 에이전트 작업",
|
||
openDamengJobAdmin: "Dameng 에이전트 작업 열기",
|
||
damengUsers: "Dameng 사용자",
|
||
openDamengUsers: "Dameng 사용자 관리 열기",
|
||
damengRoles: "Dameng 역할",
|
||
openDamengRoles: "Dameng 역할 관리 열기",
|
||
duplicateConnection: "연결 복제",
|
||
duplicateSelectedConnections: "선택한 연결 {count}개 복제",
|
||
newQuery: "새 쿼리",
|
||
addToAi: "AI에 추가",
|
||
addToAiMultiple: "AI에 추가({count}개 테이블)",
|
||
instanceInfo: "인스턴스 정보",
|
||
newSql: "새 SQL",
|
||
generateSql: "SQL 생성",
|
||
newInsert: "새 INSERT",
|
||
newUpdate: "새 UPDATE",
|
||
sqlHistory: "쿼리 기록",
|
||
noSqlHistory: "관련 SQL이 없습니다",
|
||
openObjectBrowser: "객체 탐색",
|
||
openDatabaseBrowser: "데이터베이스 탐색",
|
||
viewData: "데이터 보기",
|
||
openInNewDataTab: "새 탭에서 보기",
|
||
editStructure: "구조 편집",
|
||
editColumn: "컬럼 편집",
|
||
editIndex: "인덱스 편집",
|
||
refreshChildren: "새로고침",
|
||
collapseAll: "모두 접기",
|
||
expandAll: "모두 펼치기",
|
||
tableNameFilters: "필터...",
|
||
tableNameFiltersDescription: "포함 목록과 일치하는 객체 이름만 표시한 다음 제외 목록과 일치하는 이름을 숨깁니다. 한 줄에 하나의 SQL LIKE 패턴.",
|
||
tableNameFilterInclude: "포함 객체 이름 패턴",
|
||
tableNameFilterExclude: "제외 객체 이름 패턴",
|
||
tableNameFilterIncludePlaceholder: "예:\nads_%\nuser_%",
|
||
tableNameFilterExcludePlaceholder: "예:\n%_bak\ntmp_%",
|
||
tableNameFilterLikeHint: "SQL LIKE 문법을 사용하세요: %는 임의의 문자, _는 한 문자와 일치합니다. 대소문자를 구분하지 않습니다.",
|
||
pin: "고정",
|
||
reorderPinned: "고정 항목 재정렬",
|
||
unpin: "고정 해제",
|
||
pinTab: "탭 고정",
|
||
unpinTab: "탭 고정 해제",
|
||
refreshTab: "데이터 새로고침",
|
||
renameTab: "탭 이름 변경",
|
||
duplicateTab: "탭 복제",
|
||
splitRight: "오른쪽으로 분할",
|
||
splitDown: "아래로 분할",
|
||
changeOrientation: "분할 방향 변경",
|
||
unsplit: "분할 해제",
|
||
compactTabTitle: "탭 제목 줄이기",
|
||
fullTabTitle: "전체 탭 제목 표시",
|
||
closeTab: "탭 닫기",
|
||
editTabGroup: "탭 그룹 편집",
|
||
resetTabGroup: "탭 그룹 초기화",
|
||
closeTabGroup: "이 그룹의 탭 닫기",
|
||
closeFixedTab: "고정 탭 닫기",
|
||
closeLeftTabs: "왼쪽 탭 닫기",
|
||
closeRightTabs: "오른쪽 탭 닫기",
|
||
closeOtherTabs: "다른 탭 닫기",
|
||
closeOtherRegularTabs: "다른 일반 탭 닫기",
|
||
closeOtherFixedTabs: "다른 고정 탭 닫기",
|
||
closeAllTabs: "모든 탭 닫기",
|
||
closeAllRegularTabs: "모든 일반 탭 닫기",
|
||
closeAllFixedTabs: "모든 고정 탭 닫기",
|
||
copyName: "이름 복사",
|
||
name: "이름",
|
||
fullPath: "전체 경로",
|
||
copyFinalProxyPort: "최종 프록시 포트 복사",
|
||
finalProxyPortCopied: "최종 프록시 포트 {port} 복사됨",
|
||
setDefaultDatabase: "기본 데이터베이스로 설정",
|
||
clearDefaultDatabase: "기본 데이터베이스 지우기",
|
||
setDefaultSchema: "기본 스키마로 설정",
|
||
clearDefaultSchema: "기본 스키마 지우기",
|
||
exportDatabase: "데이터베이스 내보내기",
|
||
exportAllDatabases: "모든 데이터베이스 내보내기",
|
||
exportDatabaseSuccess: "테이블 {count}개 내보냄, 각각 최대 {limit}행",
|
||
exportDatabaseFailed: "데이터베이스 내보내기에 실패했습니다: {message}",
|
||
backupSqliteDatabase: "SQLite 데이터베이스 백업",
|
||
backupSqliteDatabaseInProgress: "SQLite 데이터베이스 백업 중...",
|
||
backupSqliteDatabaseSuccess: "SQLite 데이터베이스를 백업했습니다",
|
||
backupSqliteDatabaseFailed: "SQLite 데이터베이스 백업에 실패했습니다: {message}",
|
||
restoreSqliteDatabase: "SQLite 데이터베이스 복원",
|
||
restoreSqliteDatabaseInProgress: "SQLite 데이터베이스 복원 중...",
|
||
restoreSqliteDatabaseSuccess: "SQLite 데이터베이스를 복원했습니다",
|
||
restoreSqliteDatabaseFailed: "SQLite 데이터베이스 복원 실패: {message}",
|
||
importData: "데이터 가져오기",
|
||
exportData: "데이터 내보내기",
|
||
exportDataMultiple: "데이터 내보내기 ({count}개 테이블)",
|
||
exportDataSelectDirectory: "보낼 폴더 선택",
|
||
exportDataMultipleSuccess: "{count}개 테이블을보냈습니다",
|
||
exportStructure: "구조 내보내기",
|
||
exportStructurePreviewTitle: "구조 - {name}",
|
||
exportStructurePreviewTitleMultiple: "구조 - 객체 {count}개",
|
||
exportStructureLoading: "구조를 불러오는 중...",
|
||
copyStructure: "구조 복사",
|
||
copyStructureAs: "구조를 다른 형식으로 복사",
|
||
copyStructureAsTsv: "TSV (Excel용)",
|
||
copyStructureAsMarkdown: "마크다운 표",
|
||
structureDocTable: "테이블",
|
||
structureDocColumn: "컬럼",
|
||
structureDocType: "타입",
|
||
structureDocPrimaryKey: "기본 키",
|
||
structureDocNullable: "NULL 허용",
|
||
structureDocDefault: "기본값",
|
||
structureDocComment: "주석",
|
||
structureDocYes: "예",
|
||
structureDocNo: "아니오",
|
||
structureDocCopied: "구조를 복사했습니다",
|
||
structureDocCopyFallbackHint: "자동 복사가 차단되었습니다. 다시 복사를 클릭하거나 아래 내용을 선택하세요.",
|
||
saveStructure: "SQL 저장",
|
||
exportStructureCopied: "구조를 복사했습니다",
|
||
createTable: "테이블 만들기",
|
||
createView: "뷰 만들기",
|
||
createProcedure: "프로시저 만들기",
|
||
createFunction: "함수 만들기",
|
||
createTrigger: "트리거 만들기",
|
||
dropTable: "테이블 삭제",
|
||
emptyTable: "테이블 비우기",
|
||
truncateTable: "테이블 TRUNCATE",
|
||
duplicateStructure: "새 테이블로 복제",
|
||
renameObject: "이름 변경",
|
||
renameObjectTitle: "객체 이름 변경",
|
||
renameObjectNamePlaceholder: "새 이름",
|
||
renameObjectSuccess: '"{oldName}"을(를) "{newName}"(으)로 변경했습니다',
|
||
confirmDropTableTitle: "테이블 삭제",
|
||
confirmDropTableMessage: '"{name}"을(를) 삭제하시겠습니까? 테이블과 모든 데이터가 영구적으로 삭제됩니다.',
|
||
dropTableCascade: "CASCADE 사용",
|
||
dropTableCascadeHint: "뷰 등 종속 객체도 함께 삭제합니다. 끄면 PostgreSQL 기본 RESTRICT 동작을 사용합니다.",
|
||
truncateTableCascade: "CASCADE 사용",
|
||
truncateTableCascadeHint: "외래 키로 이 테이블을 참조하는 테이블도 함께 비웁니다. 끄면 PostgreSQL 기본 RESTRICT 동작을 사용합니다.",
|
||
confirmEmptyTableTitle: "테이블 비우기",
|
||
confirmEmptyTableMessage: '"{name}"의 모든 데이터를 삭제하시겠습니까?',
|
||
confirmTruncateTableTitle: "테이블 TRUNCATE",
|
||
confirmTruncateTableMessage: '"{name}"을(를) TRUNCATE하시겠습니까? 모든 행이 제거됩니다.',
|
||
dropTableSuccess: '테이블 "{name}" 삭제됨',
|
||
editView: "뷰 편집",
|
||
viewSource: "소스 보기",
|
||
viewDetails: "세부 정보 보기",
|
||
viewDdl: "DDL 보기",
|
||
viewDdlLoading: "DDL을 불러오는 중...",
|
||
ddlCopied: "DDL을 복사했습니다",
|
||
dropObject: "객체 삭제",
|
||
dropView: "뷰 삭제",
|
||
dropColumn: "컬럼 삭제",
|
||
dropIndex: "인덱스 삭제",
|
||
dropAllIndexes: "모든 인덱스 삭제",
|
||
createMongoIndex: "인덱스 생성",
|
||
createMongoIndexTitle: '인덱스 생성: "{collection}"',
|
||
createMongoIndexFields: "인덱스 필드",
|
||
createMongoIndexFieldRequired: "각 행에서 필드를 선택하거나 입력하세요.",
|
||
mongoIndexAscending: "오름차순 (1)",
|
||
mongoIndexDescending: "내림차순 (-1)",
|
||
createMongoIndexNamePlaceholder: "자동 생성",
|
||
createMongoIndexNameHint: "비워 두면 MongoDB가 필드와 유형으로 이름을 생성합니다.",
|
||
createMongoIndexSparse: "희소",
|
||
createMongoIndexTtlInvalid: "만료 시간은 초 단위의 정수여야 합니다.",
|
||
createMongoIndexFilterInvalid: '부분 필터는 객체여야 합니다. 예: { "status": "active" }',
|
||
createMongoIndexBucketSizeInvalid: "버킷 크기는 정수여야 합니다.",
|
||
manageMongoIndexes: "인덱스 관리",
|
||
manageMongoIndexesTitle: '인덱스: "{collection}"',
|
||
mongoIndexKeys: "키",
|
||
mongoIndexEmpty: "이 컬렉션에 인덱스가 없습니다.",
|
||
mongoIndexSelectHint: "인덱스를 선택하여 속성을 확인하세요.",
|
||
mongoIndexReadOnlyHint: "MongoDB는 기존 인덱스를 수정할 수 없습니다. 속성을 변경하려면 삭제 후 새로 만드세요.",
|
||
editMongoIndex: "인덱스 편집",
|
||
saveMongoIndex: "저장",
|
||
mongoIndexRebuildHint: "저장하면 인덱스가 재구축됩니다: 기존 인덱스가 삭제되고 새 인덱스가 생성됩니다.",
|
||
mongoEditIndexSuccess: '인덱스 "{oldName}"이(가) "{collection}"에서 "{newName}"(으)로 재구축되었습니다',
|
||
mongoEditIndexNotFound: '인덱스 "{name}"이(가) 서버에 더 이상 존재하지 않습니다. 목록이 만료되었을 수 있습니다. 새로고침 후 다시 시도하세요.',
|
||
mongoEditIndexStale: '인덱스 "{name}"이(가) 대화상자를 연 이후 다른 세션에 의해 수정되었습니다. 목록을 새로고침 후 다시 시도하세요.',
|
||
mongoEditIndexIncompleteSameName: '인덱스 "{name}"의 전체 서버 사양을 가져올 수 없어 같은 이름으로 파괴적 재구축을 수행할 수 없습니다.',
|
||
mongoEditIndexDropFailed: '인덱스 "{name}"을(를) 삭제하지 못해 대체 인덱스를 생성하지 않았습니다: {error}',
|
||
mongoEditIndexDropFailedAfterCreate: '새 인덱스 "{newName}"을(를) 생성했지만 원래 인덱스 "{oldName}"을(를) 삭제하지 못했습니다: {error}',
|
||
mongoEditIndexCreateFailedRolledBack: '인덱스 "{name}"의 대체 인덱스를 생성하지 못해 원래 인덱스를 복원했습니다: {error}',
|
||
mongoEditIndexCreateAndRollbackFailed: '인덱스 "{name}"의 대체 인덱스 생성에 실패했고({createError}) 원래 인덱스 복원에도 실패했습니다({rollbackError}).',
|
||
mongoIndexExtraOptionsPreserved: "서버에서 보고한 옵션(collation, wildcardProjection, weights 등)은 재구축 시 보존됩니다.",
|
||
dropForeignKey: "외래 키 삭제",
|
||
dropTrigger: "트리거 삭제",
|
||
batchDrop: "선택 항목 삭제 ({count})",
|
||
batchEmpty: "선택 항목 비우기 ({count})",
|
||
batchTruncate: "선택 항목 TRUNCATE ({count})",
|
||
batchMysqlAutoIncrement: "AUTO_INCREMENT 설정 ({count})",
|
||
batchDropIndexes: "인덱스 삭제 ({count})",
|
||
executeProcedure: "프로시저 실행",
|
||
confirmExecuteProcedureTitle: "프로시저 실행",
|
||
confirmExecuteProcedureMessage: '프로시저 "{name}"을(를) 실행하시겠습니까? 먼저 매개변수 값을 채우거나 조정할 수 있습니다.',
|
||
loadingProcedureParameters: "매개변수를 불러오는 중...",
|
||
procedureParametersUnavailable: "매개변수 메타데이터를 불러올 수 없습니다. 아래의 SQL을 편집하여 실행할 수 있습니다.",
|
||
noProcedureParameters: "매개변수가 없습니다. 현재 SQL이 표시된 대로 실행됩니다.",
|
||
inputParameters: "입력 매개변수 {count}개",
|
||
outputParameters: "출력 매개변수 {count}개",
|
||
parameterName: "이름",
|
||
parameterType: "타입",
|
||
parameterMode: "모드",
|
||
parameterValue: "값",
|
||
parameterNull: "NULL",
|
||
parameterDefault: "DEFAULT",
|
||
parameterDefaultHint: "DEFAULT를 선택하면 DBX가 해당 인자를 생략하여 데이터베이스가 프로시저 기본값을 사용합니다.",
|
||
parameterValuePlaceholder: "값 입력",
|
||
outputOnly: "출력 전용",
|
||
sqlPreview: "SQL 미리보기",
|
||
resetSqlPreview: "SQL 재설정",
|
||
openInSqlEditor: "편집기에서 열기",
|
||
dropProcedure: "프로시저 삭제",
|
||
dropFunction: "함수 삭제",
|
||
manageExtension: "확장 관리...",
|
||
dropExtension: "확장 삭제",
|
||
confirmDropViewTitle: "뷰 삭제",
|
||
confirmDropViewMessage: '뷰 "{name}"을(를) 삭제하시겠습니까?',
|
||
confirmDropObjectTitle: "객체 삭제",
|
||
confirmDropObjectMessage: '"{name}"을(를) 삭제하시겠습니까?',
|
||
confirmDropColumnTitle: "컬럼 삭제",
|
||
confirmDropIndexTitle: "인덱스 삭제",
|
||
confirmDropMongoIndexMessage: '컬렉션 "{collection}"에서 인덱스 "{name}"을(를) 삭제하시겠습니까?',
|
||
confirmDropMongoAllIndexesMessage: '컬렉션 "{name}"에서 제거 가능한 모든 인덱스를 삭제하시겠습니까?',
|
||
confirmDropMongoAllIndexesDetails: 'MongoDB는 "_id_" 인덱스를 유지합니다. 샤드 키가 필요한 추가 인덱스도 남을 수 있으며, 결과에는 실제로 삭제된 인덱스만 표시됩니다.',
|
||
confirmDropForeignKeyTitle: "외래 키 삭제",
|
||
confirmDropTriggerTitle: "트리거 삭제",
|
||
confirmDropTableChildObjectMessage: '"{table}"에서 "{name}"을(를) 삭제하시겠습니까?',
|
||
confirmDropBatchIndexesMessage: '"{table}"에서 선택한 인덱스 {count}개를 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.',
|
||
confirmBatchDropTitle: "선택한 객체 삭제",
|
||
confirmBatchDropMessage: "선택한 객체 {count}개를 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.",
|
||
confirmBatchEmptyTitle: "선택한 테이블 비우기",
|
||
confirmBatchEmptyMessage: "선택한 테이블 {count}개의 모든 데이터를 삭제하시겠습니까?",
|
||
confirmBatchTruncateTitle: "선택한 테이블 TRUNCATE",
|
||
confirmBatchTruncateMessage: "선택한 테이블 {count}개를 TRUNCATE하시겠습니까? 모든 행이 제거됩니다.",
|
||
batchMysqlAutoIncrementTitle: "MySQL AUTO_INCREMENT 설정 ({count}개 테이블)",
|
||
batchMysqlAutoIncrementMessage: "선택한 {count}개 테이블의 다음 AUTO_INCREMENT 값을 설정하시겠습니까?",
|
||
batchMysqlAutoIncrementSuccess: "{count}개 테이블에 AUTO_INCREMENT {value} 설정 완료",
|
||
batchMysqlAutoIncrementPartialFail: "{success}개 테이블에 AUTO_INCREMENT 설정, {failed}개 실패",
|
||
confirmDropProcedureTitle: "프로시저 삭제",
|
||
confirmDropProcedureMessage: '프로시저 "{name}"을(를) 삭제하시겠습니까?',
|
||
confirmDropFunctionTitle: "함수 삭제",
|
||
confirmDropFunctionMessage: '함수 "{name}"을(를) 삭제하시겠습니까?',
|
||
dropViewSuccess: '뷰 "{name}" 삭제됨',
|
||
dropProcedureSuccess: '프로시저 "{name}" 삭제됨',
|
||
dropFunctionSuccess: '함수 "{name}" 삭제됨',
|
||
dropTableChildObjectSuccess: '"{name}" 삭제됨',
|
||
dropAllIndexesSuccess: '"{name}"에서 인덱스 {count}개 삭제됨',
|
||
dropIndexesPartialFailure: "인덱스 {success}개를 삭제했고 {failed}개는 실패했습니다.",
|
||
createMongoIndexSuccess: '"{collection}"에 인덱스 "{name}" 생성됨',
|
||
mongoIndexRefreshFailed: "작업 후 인덱스 목록을 새로 고칠 수 없습니다: {message}",
|
||
batchDropSuccess: "객체 {count}개 삭제됨",
|
||
batchEmptySuccess: "테이블 {count}개 비움",
|
||
batchEmptyPartialFail: "테이블 {success}개 비움, {failed}개 실패",
|
||
batchEmptySubmitted: "테이블 {count}개의 비우기 작업 제출됨",
|
||
batchEmptySubmittedPartial: "비우기 작업 {success}개 제출, {failed}개 실패",
|
||
batchTruncateSuccess: "테이블 {count}개 TRUNCATE",
|
||
emptyTableSuccess: '"{name}"의 모든 데이터 삭제됨',
|
||
emptyTableSubmitted: '"{name}"의 비우기 작업이 제출되었습니다',
|
||
truncateTableSuccess: '테이블 "{name}" TRUNCATE됨',
|
||
duplicateStructureSuccess: '테이블이 "{name}"(으)로 복제됨',
|
||
tableOperationFailed: "작업 실패: {message}",
|
||
tableOperationTimedOut: '"{name}"에 대한 작업이 예상보다 오래 걸리고 있으며 취소되지 않았습니다. 데이터베이스에서 계속 실행 중일 수 있습니다. 나중에 결과를 확인하거나 취소를 클릭하여 중지하세요. ({message})',
|
||
tableOperationCancelled: '"{name}" 작업이 취소되었습니다',
|
||
tableOperationCancelUnconfirmed: '"{name}"에 대한 취소 요청이 데이터베이스에서 확인되지 않았습니다. 작업이 이미 완료되었거나 계속 실행 중일 수 있습니다. 실제 결과를 확인하세요. ({message})',
|
||
tableOperationCancelPending: '"{name}"에 대한 취소 요청이 아직 확인되지 않았습니다. 데이터베이스에서 계속 실행 중일 수 있습니다. 다시 취소를 시도하거나 잠시 후 확인해 보세요.',
|
||
dangerOperationAlreadyRunning: "다른 위험한 작업이 아직 실행 중입니다. 완료되기를 기다리거나 취소한 후 새 작업을 시작하세요.",
|
||
objectDropRefreshFailed: "개체는 삭제되었지만 사이드바 새로 고침에 실패했습니다: {message}",
|
||
duplicateNameTitle: "새 테이블로 복제",
|
||
duplicateNamePlaceholder: "새 테이블 이름",
|
||
copyTable: "테이블 복사",
|
||
pasteTable: "테이블 붙여넣기",
|
||
pasteOptionStructureAndData: "구조와 데이터",
|
||
pasteOptionStructureOnly: "구조만",
|
||
pasteOptionDataOnly: "데이터만",
|
||
pasteTableSuccess: '테이블이 "{name}"(으)로 붙여넣어짐',
|
||
pasteTableConfirmTitle: "테이블 붙여넣기",
|
||
pasteTableConfirmMessage: "클립보드에서 테이블 붙여넣기",
|
||
batchPasteTitle: "테이블 붙여넣기",
|
||
batchPasteSuccess: "테이블 {count}개를 붙여넣었습니다",
|
||
batchPastePartialFail: "테이블 {success}개 붙여넣음, {failed}개 실패",
|
||
noTableToPaste: "붙여넣을 테이블이 없습니다",
|
||
pasteTableClipboardUpdated: "테이블이 클립보드에 복사되었습니다",
|
||
createDatabase: "데이터베이스 만들기",
|
||
createDuckDbFile: "데이터베이스 파일 만들기",
|
||
attachSqliteDatabase: "SQLite 데이터베이스 연결",
|
||
dropDatabase: "데이터베이스 삭제",
|
||
confirmDropDatabaseTitle: "데이터베이스 삭제",
|
||
confirmDropDatabaseMessage: '데이터베이스 "{name}"을(를) 삭제하시겠습니까? 데이터베이스와 모든 데이터가 영구적으로 삭제됩니다.',
|
||
createDatabaseSuccess: '데이터베이스 "{name}" 생성됨',
|
||
mysqlCreateDatabasePermissionHint: "현재 MySQL 계정은 이 데이터베이스를 만들 수 없습니다. root라는 이름의 계정이 반드시 관리자 권한을 가지는 것은 아닙니다. GRANT OPTION이 있는 관리자 계정으로 CREATE 권한을 부여한 후 다시 시도하세요.",
|
||
createDatabasePartial: '데이터베이스 "{name}"이(가) 생성되었지만 일부 권한 부여에 실패했습니다',
|
||
createDatabaseFailed: '데이터베이스 "{name}"을(를) 만들 수 없습니다',
|
||
createDatabaseUsers: "사용자에게 접근 권한 부여",
|
||
createDatabaseUsersHint: "선택한 사용자는 데이터베이스가 생성된 후 전체 네이티브 접근 권한을 받습니다.",
|
||
createDatabaseUsersSelected: "{count}개 선택됨",
|
||
createDatabaseUsersLoading: "사용자를 불러오는 중...",
|
||
createDatabaseUsersLoadFailed: "사용자를 불러올 수 없습니다: {message}",
|
||
previewCreateDatabaseSql: "SQL 미리보기",
|
||
createDatabaseSqlPreview: "데이터베이스 만들기 SQL 미리보기",
|
||
applyCreateDatabaseSql: "만들기 및 권한 부여",
|
||
closeCreateDatabaseResult: "닫기",
|
||
createDatabaseStep: '데이터베이스 "{database}" 만들기',
|
||
createDatabaseGrantStep: '"{database}"에서 {user}에게 데이터베이스 접근 권한 부여',
|
||
createDatabaseGrantObjectsStep: '"{database}"에서 {user}에게 스키마 및 객체 접근 권한 부여',
|
||
createDatabaseStepSkipped: "필요한 이전 단계가 실패하여 건너뜁니다.",
|
||
editDatabaseProperties: "데이터베이스 속성 편집",
|
||
editDatabasePropertiesTitle: '데이터베이스 속성 편집: "{name}"',
|
||
editDatabasePropertiesSaving: "저장 중...",
|
||
editDatabasePropertiesSuccess: '데이터베이스 "{name}" 속성이 업데이트되었습니다',
|
||
editDatabaseComment: "데이터베이스 주석",
|
||
editDatabaseCommentPlaceholder: "데이터베이스 주석 입력...",
|
||
createDuckDbFileSuccess: 'DuckDB 데이터베이스 파일 "{name}"이(가) 생성되어 연결되었습니다',
|
||
createDuckDbFileDesktopOnly: "DuckDB 데이터베이스 파일 만들기는 데스크톱 앱에서만 사용할 수 있습니다",
|
||
attachSqliteDatabaseSuccess: 'SQLite 데이터베이스 "{name}"이(가) 연결되었습니다',
|
||
attachSqliteDatabaseDesktopOnly: "SQLite 데이터베이스 파일 연결은 데스크톱 앱에서만 사용할 수 있습니다",
|
||
dropDatabaseSuccess: '데이터베이스 "{name}" 삭제됨',
|
||
dropCollection: "컬렉션 삭제",
|
||
elasticsearchViewMapping: "매핑 보기",
|
||
elasticsearchViewSettings: "인덱스 설정 보기",
|
||
elasticsearchViewStats: "인덱스 통계 보기",
|
||
elasticsearchClearIndex: "인덱스 데이터 비우기",
|
||
elasticsearchClearIndexMessage: "인덱스 {index}의 모든 문서를 삭제합니다. 매핑, 설정, 별칭은 유지됩니다. 계속할까요?",
|
||
elasticsearchClearIndexPatternMessage: "{index}는 단일 인덱스가 아니라 그룹화된 와일드카드 패턴입니다. 일치하는 모든 인덱스의 문서가 삭제됩니다. 매핑, 설정, 별칭은 유지됩니다. 계속할까요?",
|
||
elasticsearchClearIndexTypeToConfirm: "확인하려면 {index}를 입력하세요",
|
||
elasticsearchClearIndexDetails: "_delete_by_query로 문서를 삭제하며 인덱스 자체는 삭제되지 않습니다.",
|
||
elasticsearchClearIndexConfirm: "데이터 비우기",
|
||
elasticsearchClearIndexDone: "{index} 비움: 문서 {deleted}건 삭제",
|
||
elasticsearchClearIndexPartial: "{index}가 완전히 비워지지 않았습니다: {total}건 중 {deleted}건 삭제. 충돌 또는 샤드 실패를 확인한 뒤 다시 실행하세요.",
|
||
cloneCollection: "컬렉션 복제",
|
||
cloneCollectionTitle: "새 컬렉션으로 복제",
|
||
cloneCollectionNamePlaceholder: "새 컬렉션 이름",
|
||
cloneCollectionSuccess: '컬렉션 "{name}"을(를) 복제했습니다(문서 {documents}개, 인덱스 {indexes}개)',
|
||
confirmDropCollectionTitle: "컬렉션 삭제",
|
||
confirmDropCollectionMessage: '컬렉션 "{name}"을(를) 삭제하시겠습니까? 컬렉션과 모든 문서가 영구적으로 삭제됩니다.',
|
||
dropCollectionSuccess: '컬렉션 "{name}" 삭제됨',
|
||
createDatabaseNamePlaceholder: "데이터베이스 이름",
|
||
createDatabaseCharset: "문자셋",
|
||
createDatabaseCharsetPlaceholder: "예: utf8mb4",
|
||
createDatabaseCharsetSearchPlaceholder: "문자셋 검색 또는 입력",
|
||
createDatabaseCharsetEmpty: "문자셋이 없습니다",
|
||
createDatabaseCharsetLoading: "문자셋을 불러오는 중...",
|
||
createDatabaseCharsetCustomOption: '"{value}" 사용',
|
||
createDatabaseCollation: "정렬",
|
||
createDatabaseCollationPlaceholder: "예: utf8mb4_unicode_ci",
|
||
createDatabaseCollationSearchPlaceholder: "정렬 검색 또는 입력",
|
||
createDatabaseCollationEmpty: "정렬이 없습니다",
|
||
createDatabaseCollationLoading: "정렬을 불러오는 중...",
|
||
createDatabaseCollationCustomOption: '"{value}" 사용',
|
||
createSchema: "스키마 만들기",
|
||
dropSchema: "스키마 삭제",
|
||
confirmDropSchemaTitle: "스키마 삭제",
|
||
confirmDropSchemaMessage: '스키마 "{name}"을(를) 삭제하시겠습니까? 스키마와 모든 객체가 영구적으로 삭제됩니다.',
|
||
createSchemaSuccess: '스키마 "{name}" 생성됨',
|
||
dropSchemaSuccess: '스키마 "{name}" 삭제됨',
|
||
dropDamengSchemaRequiresDifferentDba: "현재 연결에서는 이 스키마를 안전하게 삭제할 수 없습니다. 다른 DBA 사용자로 연결한 후 다시 시도하세요.",
|
||
createSchemaNamePlaceholder: "스키마 이름",
|
||
editSchemaComment: "주석 편집",
|
||
editSchemaCommentTitle: '주석 편집: "{name}"',
|
||
schemaCommentPlaceholder: "스키마 주석 입력...",
|
||
schemaCommentSaving: "저장 중...",
|
||
editSchemaCommentSuccess: '스키마 "{name}" 주석이 업데이트되었습니다',
|
||
viewObject: "View",
|
||
eventEditorTitle: "MySQL Event",
|
||
eventDefinition: "Definition",
|
||
eventSchedule: "Schedule",
|
||
eventComment: "Comment",
|
||
eventSqlPreview: "SQL preview",
|
||
eventName: "Name",
|
||
eventBodyPlaceholder: "Event body, e.g. CALL procedure();",
|
||
eventExecuteAt: "Execute at",
|
||
eventIntervalValue: "Interval value",
|
||
eventIntervalUnit: "Interval unit",
|
||
eventStarts: "Starts",
|
||
eventEnds: "Ends",
|
||
eventCompletion: "Completion",
|
||
eventStatus: "Status",
|
||
eventCommentPlaceholder: "Optional comment",
|
||
eventLoading: "Loading...",
|
||
eventCancel: "Cancel",
|
||
eventSave: "Save",
|
||
refreshDdlOnOpen: "열 때마다 새로 고침",
|
||
refreshDdlOnOpenHint: "켜면 열 때마다 데이터베이스에서 DDL을 다시 불러오고, 끄면 캐시된 데이터를 우선 사용합니다",
|
||
viewDependencies: "의존 관계 보기",
|
||
copyConnectionInfo: "연결 정보 복사",
|
||
copyConnectionUrl: "연결 URL",
|
||
copyConnectionUrlWithPassword: "연결 URL(비밀번호 포함)",
|
||
copyJdbcUrl: "JDBC URL",
|
||
copyJdbcUrlWithCredentials: "JDBC URL(계정 및 비밀번호 포함)",
|
||
copyHostPort: "호스트:포트",
|
||
copyDsn: "DSN(key=value)",
|
||
copyDsnWithPassword: "DSN(비밀번호 포함)",
|
||
copyPsqlCommand: "psql 명령어",
|
||
copyPasswordConfirmTitle: "비밀번호 포함 복사",
|
||
copyPasswordConfirmMessage: "복사되는 텍스트에 저장된 비밀번호가 평문으로 포함됩니다. 계속할까요?",
|
||
copyPasswordConfirmAction: "복사",
|
||
},
|
||
visibleDatabases: {
|
||
title: "표시할 데이터베이스",
|
||
detailLabel: "표시할 데이터베이스",
|
||
detailActionLabel: '"{connection}"의 표시할 데이터베이스 구성',
|
||
description: '"{connection}" 아래에 표시할 데이터베이스를 선택하세요.',
|
||
searchPlaceholder: "데이터베이스 검색...",
|
||
selectedCount: "{selected}/{total} 선택됨",
|
||
patternsPlaceholder: "와일드카드(예: %n1%), 쉼표로 구분",
|
||
patternsHint: "이 패턴과 일치하는 데이터베이스는 항상 표시됩니다(% = 임의의 문자, _ = 단일 문자)",
|
||
patternsMatchCount: "{count}개 일치",
|
||
selectAll: "모두 선택",
|
||
selectFiltered: "검색 결과 선택",
|
||
clear: "지우기",
|
||
showAll: "모두 표시",
|
||
showSystemDatabases: "시스템 데이터베이스 표시",
|
||
save: "저장",
|
||
emptySelection: "최소 한 개의 데이터베이스를 선택하거나, 모두 표시를 사용해 필터를 지우세요.",
|
||
loadFailed: "데이터베이스를 불러오는 데 실패했습니다: {message}",
|
||
},
|
||
visibleSchemas: {
|
||
title: "스키마 필터",
|
||
detailLabel: "표시할 스키마",
|
||
detailActionLabel: '"{connection}"의 표시할 스키마 구성',
|
||
description: '"{connection}" 아래에 표시할 스키마를 선택하세요.',
|
||
searchPlaceholder: "스키마 검색...",
|
||
selectedCount: "{selected}/{total} 선택됨",
|
||
selectAll: "모두 선택",
|
||
selectFiltered: "검색 결과 선택",
|
||
clear: "지우기",
|
||
showAll: "모두 표시",
|
||
showSystemSchemas: "시스템 스키마 표시",
|
||
save: "저장",
|
||
emptySelection: "최소 한 개의 스키마를 선택하거나, 모두 표시를 사용해 필터를 지우세요.",
|
||
loadFailed: "스키마를 불러오는 데 실패했습니다: {message}",
|
||
},
|
||
databaseLinks: {
|
||
shadowed: "A private link with the same name takes precedence in this session.",
|
||
search: "Search database links",
|
||
name: "Link name",
|
||
owner: "Owner",
|
||
username: "Remote user",
|
||
host: "Connect string",
|
||
password: "Remote password",
|
||
public: "Public link (requires CREATE PUBLIC DATABASE LINK)",
|
||
create: "Create link",
|
||
alter: "Update credentials",
|
||
test: "Test link",
|
||
testSuccess: "Database link query succeeded.",
|
||
empty: "No accessible database links.",
|
||
saved: "Database link updated.",
|
||
alterHint: "Update the stored remote password for {name}. To change the user or connect string, create a new link.",
|
||
dropConfirm: "Delete database link {owner} / {name}? This does not delete remote data.",
|
||
manage: "Manage database links",
|
||
},
|
||
tree: {
|
||
databaseLinks: "Database Links",
|
||
savedSql: "SQL 라이브러리",
|
||
queries: "쿼리",
|
||
userAdmin: "사용자 및 권한",
|
||
damengUsers: "사용자",
|
||
damengRoles: "역할",
|
||
damengJobAdmin: "에이전트 작업",
|
||
xuguTablespaces: "저장 공간",
|
||
xuguDatafiles: "파일",
|
||
xuguStorage: {
|
||
name: "이름",
|
||
nodeId: "노드 ID",
|
||
spaceId: "테이블스페이스 ID",
|
||
spaceType: "테이블스페이스 유형",
|
||
datafileCount: "데이터 파일 수",
|
||
totalChunks: "전체 청크",
|
||
freeChunks: "사용 가능한 청크",
|
||
usedChunks: "사용된 청크",
|
||
usage: "사용률",
|
||
mediaError: "미디어 오류",
|
||
path: "경로",
|
||
fileNo: "파일 번호",
|
||
currentSize: "현재 크기",
|
||
maxSize: "최대 크기",
|
||
stepSize: "증가 단위",
|
||
reserved: "예약 필드",
|
||
unlimited: "무제한",
|
||
yes: "예",
|
||
no: "아니요",
|
||
},
|
||
linkedServers: "연결된 서버",
|
||
defaultDatabase: "기본 DB",
|
||
elasticsearchAlias: "별칭",
|
||
columns: "컬럼",
|
||
attributes: "속성",
|
||
methods: "메서드",
|
||
indexes: "인덱스",
|
||
foreignKeys: "외래 키",
|
||
triggers: "트리거",
|
||
events: "이벤트",
|
||
constraints: "제약 조건",
|
||
tables: "테이블",
|
||
tableNameFilterActive: "필터됨",
|
||
views: "뷰",
|
||
materializedViews: "구체화된 뷰",
|
||
procedures: "프로시저",
|
||
functions: "함수",
|
||
sequences: "시퀀스",
|
||
schedulerJobs: "예약된 작업",
|
||
synonyms: "동의어",
|
||
packages: "패키지",
|
||
types: "타입",
|
||
gridfs: "GridFS",
|
||
buckets: "버킷",
|
||
partitions: "파티션",
|
||
subpartitions: "하위 파티션",
|
||
childTables: "하위 테이블",
|
||
loadMore: "더 불러오기...",
|
||
objectBrowser: "객체 브라우저에서 탐색 ({count})",
|
||
extensions: "확장",
|
||
},
|
||
extension: {
|
||
manageTitle: "확장 관리",
|
||
installTitle: "확장 설치",
|
||
detailsTitle: "확장 세부 정보",
|
||
viewDetails: "세부 정보 보기",
|
||
name: "확장 이름",
|
||
namePlaceholder: "예: pg_stat_statements",
|
||
install: "설치",
|
||
drop: "삭제",
|
||
available: "사용 가능",
|
||
installed: "설치됨",
|
||
noAvailable: "사용 가능한 모든 확장이 이미 설치되어 있습니다.",
|
||
noInstalled: "설치된 확장이 없습니다.",
|
||
},
|
||
xuguSchedulerJob: {
|
||
enable: "활성화",
|
||
disable: "비활성화",
|
||
run: "지금 실행",
|
||
drop: "작업 삭제",
|
||
confirmDrop: '예약된 작업 "{name}"을(를) 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.',
|
||
actionSuccess: '"{name}"에 대한 {action}이(가) 완료되었습니다.',
|
||
},
|
||
processList: {
|
||
batchCancel: "선택한 쿼리 취소 ({count})",
|
||
batchNeedsSession: "현재 세션을 확인할 수 없습니다. 새로 고침 후 다시 시도하세요.",
|
||
selectAll: "현재 필터에서 로드된 선택 가능한 세션 모두 선택",
|
||
selectSession: "세션 {id} 선택",
|
||
batchTitle: "선택한 쿼리 취소",
|
||
batchConfirm: "이 {count}개 세션에서 실행 중인 쿼리를 취소하시겠습니까? 세션 연결은 유지됩니다.",
|
||
batchRunning: "쿼리 취소 중…",
|
||
batchSummary: "취소 요청: 성공 {succeeded}개, 실패 {failed}개.",
|
||
title: "프로세스 목록",
|
||
sessionCount: "{count}개 세션",
|
||
filter: "세션 필터",
|
||
autoRefresh: "자동 새로고침",
|
||
seconds: "초",
|
||
colId: "ID",
|
||
colUser: "사용자",
|
||
colHost: "호스트",
|
||
colDb: "DB",
|
||
colCommand: "명령",
|
||
colTime: "시간",
|
||
colState: "상태",
|
||
colInfo: "정보",
|
||
colPid: "PID",
|
||
colClient: "클라이언트",
|
||
colApp: "애플리케이션",
|
||
colWait: "대기",
|
||
colQuery: "쿼리",
|
||
colActions: "작업",
|
||
self: "나",
|
||
kill: "쿼리 취소",
|
||
cannotKillSelf: "현재 세션의 쿼리는 취소할 수 없습니다",
|
||
empty: "활성 세션이 없습니다.",
|
||
killTitle: "실행 중인 쿼리 취소",
|
||
killConfirm: "세션 {id} ({user})에서 실행 중인 쿼리를 취소하시겠습니까? 세션 연결은 유지됩니다.",
|
||
killSuccess: "세션 {id}에서 실행 중인 쿼리를 취소했습니다",
|
||
killFailed: "쿼리 취소에 실패했습니다: {message}",
|
||
previewTitle: "구문",
|
||
copy: "복사",
|
||
copied: "복사했습니다",
|
||
},
|
||
serverDashboard: {
|
||
title: "서버 대시보드",
|
||
autoRefresh: "자동 새로고침",
|
||
off: "꺼짐",
|
||
qps: "초당 쿼리",
|
||
connections: "연결",
|
||
running: "실행 중인 스레드",
|
||
trafficIn: "들어오는 트래픽",
|
||
trafficOut: "나가는 트래픽",
|
||
slowQueries: "느린 쿼리",
|
||
uptime: "가동 시간",
|
||
innodbHit: "InnoDB 적중률",
|
||
in: "수신",
|
||
out: "송신",
|
||
sessions: "세션",
|
||
qpsChart: "초당 쿼리",
|
||
sessionsChart: "초당 세션",
|
||
trafficChart: "초당 네트워크 트래픽",
|
||
commandChart: "초당 명령",
|
||
rawStatus: "상태 변수",
|
||
filterStatus: "상태 변수 필터",
|
||
tps: "초당 트랜잭션",
|
||
activeQueries: "활성 쿼리",
|
||
cacheHit: "캐시 적중률",
|
||
deadlocks: "교착 상태",
|
||
tempFiles: "임시 파일",
|
||
walRate: "WAL 비율",
|
||
commit: "커밋",
|
||
rollback: "롤백",
|
||
total: "전체",
|
||
active: "활성",
|
||
idle: "유휴",
|
||
fetched: "가져옴",
|
||
returned: "반환",
|
||
read: "읽기",
|
||
hits: "적중",
|
||
serverSessionsChart: "서버 세션",
|
||
transactionsChart: "초당 트랜잭션",
|
||
tuplesInChart: "들어오는 튜플",
|
||
tuplesOutChart: "나가는 튜플",
|
||
blockIoChart: "블록 I/O",
|
||
},
|
||
userAdmin: {
|
||
title: "사용자 및 권한",
|
||
unsupported: "MySQL 호환 및 PostgreSQL 호환 연결을 지원합니다. SQL Server, Oracle 및 기타 권한 모델은 추후 추가될 수 있습니다.",
|
||
newUser: "새 사용자",
|
||
anonymous: "익명",
|
||
roleName: "역할 이름",
|
||
allowLogin: "로그인 허용",
|
||
searchUser: "사용자 또는 호스트 검색",
|
||
loadingUsers: "사용자를 불러오는 중...",
|
||
loadingGrants: "권한을 불러오는 중...",
|
||
emptyUsers: "사용자가 없거나, 현재 계정이 사용자 목록을 읽을 수 없습니다.",
|
||
pluginUnknown: "알 수 없는 인증 플러그인",
|
||
grants: "권한",
|
||
noGrants: "권한이 없습니다",
|
||
privilegeEditor: "권한 편집기",
|
||
privilegeHint: "권한, 데이터베이스, 테이블을 선택한 다음 적용 전에 SQL을 미리보세요. *는 전역 또는 모든 테이블을 의미합니다.",
|
||
database: "데이터베이스",
|
||
schema: "스키마",
|
||
table: "테이블",
|
||
scope: "권한 부여 범위",
|
||
scopeDatabase: "데이터베이스",
|
||
scopeSchema: "스키마",
|
||
scopeTable: "테이블",
|
||
scopeRole: "역할 멤버십",
|
||
memberRole: "멤버 역할",
|
||
privileges: "권한",
|
||
grantOption: "추가 권한 부여 허용 (WITH GRANT OPTION)",
|
||
adminOption: "멤버십 관리 허용 (WITH ADMIN OPTION)",
|
||
grant: "권한 부여",
|
||
revoke: "권한 회수",
|
||
username: "사용자 이름",
|
||
host: "호스트",
|
||
changeHost: "호스트 변경",
|
||
newHost: "새 호스트",
|
||
changePassword: "비밀번호 변경",
|
||
newPassword: "새 비밀번호",
|
||
lock: "잠금",
|
||
unlock: "잠금 해제",
|
||
disableLogin: "로그인 비활성화",
|
||
enableLogin: "로그인 활성화",
|
||
dropUser: "사용자 삭제",
|
||
previewSql: "SQL 미리보기",
|
||
sqlPreview: "SQL 미리보기",
|
||
applySql: "SQL 적용",
|
||
applySuccess: "사용자 권한이 업데이트되었습니다",
|
||
applyPartial: "사용자가 생성되었지만 일부 권한 부여에 실패했습니다",
|
||
applyFailedSummary: "작업이 실패했습니다",
|
||
applyFailed: "실행 실패: {message}",
|
||
applyFailedUnknown: "실행 실패",
|
||
standardUser: "표준 사용자",
|
||
standardUserHint: "아래에서 선택한 데이터베이스와 권한만 부여합니다.",
|
||
adminUser: "관리자 사용자",
|
||
adminUserHint: "인스턴스 수준의 고권한 계정을 만듭니다.",
|
||
adminUserWarning: "이 계정은 데이터베이스와 다른 사용자를 관리할 수 있습니다. 적용하기 전에 전체 SQL을 주의 깊게 검토하세요.",
|
||
databaseAccess: "데이터베이스 접근",
|
||
databaseAccessHint: "데이터베이스를 선택하고 각각에 대해 별도의 권한 수준을 구성하세요.",
|
||
tableScope: "테이블 범위",
|
||
allTables: "모든 테이블",
|
||
specificTables: "지정 테이블",
|
||
chooseTables: "테이블 선택",
|
||
selectedTableCount: "테이블 {count}개 선택됨",
|
||
searchTable: "테이블 검색",
|
||
loadingTables: "테이블을 불러오는 중...",
|
||
emptyTables: "테이블이 없습니다",
|
||
loadTablesFailed: "테이블을 불러올 수 없습니다: {message}",
|
||
tableSelectionRequired: "테이블을 하나 이상 선택하세요.",
|
||
selectAllTables: "모두 선택",
|
||
clearAllTables: "지우기",
|
||
retry: "다시 시도",
|
||
selectedDatabaseCount: "데이터베이스 {count}개",
|
||
searchDatabase: "데이터베이스 검색",
|
||
loadingDatabases: "데이터베이스를 불러오는 중...",
|
||
emptyDatabases: "데이터베이스가 없습니다",
|
||
loadDatabasesFailed: "데이터베이스를 불러올 수 없습니다: {message}",
|
||
prepareAuthorizationFailed: "데이터베이스 권한을 준비할 수 없습니다: {message}",
|
||
presetReadWrite: "읽기/쓰기",
|
||
presetReadOnly: "읽기 전용",
|
||
presetDdl: "DDL 전용",
|
||
presetDml: "DML 전용",
|
||
presetCustom: "사용자 지정",
|
||
customPrivilegeRequired: "최소 한 개의 권한을 선택하세요.",
|
||
postgresDdlHint: "PostgreSQL은 데이터베이스/스키마에 CREATE 권한을 부여합니다. 객체를 변경하거나 삭제하려면 여전히 소유권이 필요합니다.",
|
||
resultSuccess: "모든 단계가 성공적으로 완료되었습니다",
|
||
resultPartial: "부분적으로 완료됨",
|
||
resultFailed: "실행 실패",
|
||
closeResult: "닫기",
|
||
stepCreateUser: "사용자 또는 역할 만들기",
|
||
stepGrantAdmin: "{user}에게 관리자 권한 부여",
|
||
stepGrantDatabase: '{user}에게 데이터베이스 "{database}" 접근 권한 부여',
|
||
stepGrantTable: '{user}에게 테이블 "{database}.{table}" 접근 권한 부여',
|
||
stepGrantObjects: '"{database}"에서 {user}에게 스키마 및 객체 권한 부여',
|
||
stepGrantCurrentObjects: '"{database}"에서 "{schema}" 스키마의 현재 {scope}을(를) {user}에게 부여',
|
||
stepGrantFutureObjects: '"{database}"에서 현재 역할이 생성할 향후 {scope}을(를) {user}에게 부여',
|
||
stepGrantFutureObjectsForOwner: '"{database}"에서 {owner}이(가) 생성할 향후 {scope}을(를) {user}에게 부여',
|
||
scopeSchemas: "스키마",
|
||
scopeTables: "테이블",
|
||
scopeSequences: "시퀀스",
|
||
scopeFunctions: "함수",
|
||
stepSkipped: "필요한 이전 단계가 실패하여 건너뜁니다.",
|
||
},
|
||
damengJobAdmin: {
|
||
title: "Dameng 에이전트 작업",
|
||
unsupported: "이 페이지는 Dameng 연결만 지원합니다.",
|
||
initEnvironment: "작업 환경 초기화",
|
||
environmentReady: "작업 환경 준비됨",
|
||
newJob: "새 작업",
|
||
searchJob: "작업 검색",
|
||
loadFailed: "불러오기 실패",
|
||
environmentMissingTitle: "작업 환경이 초기화되지 않았습니다",
|
||
environmentMissingHint: "이 데이터베이스에는 아직 SYSJOB 작업 환경이 없습니다.",
|
||
environmentMissingDescription: "Dameng 에이전트 작업에는 SYSJOB 스키마 아래의 시스템 테이블과 뷰가 필요합니다. 먼저 작업 환경을 초기화하세요. 일반적으로 관리자 권한이 필요합니다.",
|
||
emptyJobs: "작업이 없거나, 현재 계정이 작업 목록을 읽을 수 없습니다.",
|
||
emptyDetails: "상세 행이 없습니다",
|
||
selectJob: "작업을 선택하세요",
|
||
enabled: "활성화됨",
|
||
disabled: "비활성화됨",
|
||
running: "실행 중",
|
||
enable: "활성화",
|
||
disable: "비활성화",
|
||
runAsync: "지금 실행",
|
||
stopRunning: "현재 실행 중지",
|
||
stopRunningDisabled: "현재 실행 중인 작업만 중지할 수 있습니다",
|
||
clearHistories: "기록 비우기",
|
||
dropJob: "삭제",
|
||
steps: "단계",
|
||
schedules: "일정",
|
||
histories: "기록",
|
||
noDescription: "설명 없음",
|
||
jobName: "작업 이름",
|
||
description: "설명",
|
||
stepName: "단계 이름",
|
||
scheduleName: "일정 이름",
|
||
sqlCommand: "SQL 스크립트",
|
||
scheduleMode: "일정 유형",
|
||
daily: "매일",
|
||
once: "한 번",
|
||
startDate: "시작 날짜",
|
||
startTime: "시작 시간",
|
||
endTime: "종료 시간",
|
||
minuteInterval: "분 간격",
|
||
previewSql: "SQL 미리보기",
|
||
sqlPreview: "SQL 미리보기",
|
||
applySql: "SQL 적용",
|
||
applySuccess: "작업 작업이 적용되었습니다",
|
||
applyFailed: "실행 실패: {message}",
|
||
},
|
||
damengUserAdmin: {
|
||
title: "Dameng 사용자",
|
||
unsupported: "이 페이지는 Dameng 데이터베이스 연결만 지원합니다.",
|
||
newUser: "새 사용자",
|
||
searchUser: "사용자 검색",
|
||
loadFailed: "불러오기 실패",
|
||
emptyUsers: "사용자가 없거나 현재 계정에 사용자 목록을 읽을 권한이 없습니다.",
|
||
selectUser: "사용자를 선택하세요",
|
||
username: "사용자 이름",
|
||
usernamePlaceholder: "예: APP_USER",
|
||
password: "비밀번호",
|
||
passwordPolicyHint: "비밀번호는 DM8 암호 정책을 충족해야 합니다(기본: 9자 이상, 대소문자와 숫자 조합 권장)",
|
||
tablespace: "기본 테이블스페이스",
|
||
tablespacePlaceholder: "테이블스페이스 이름 입력",
|
||
locked: "생성 후 계정 잠금",
|
||
changePassword: "비밀번호 변경",
|
||
newPassword: "새 비밀번호",
|
||
confirmPassword: "비밀번호 확인",
|
||
open: "정상",
|
||
systemUser: "시스템 사용자",
|
||
systemUserAdmin: "관리 사용자",
|
||
systemUserAuditor: "감사 사용자",
|
||
systemUserSecurity: "보안 사용자",
|
||
systemUserSystem: "시스템 사용자",
|
||
cannotChangePassword: "이 사용자의 비밀번호는 현재 연결에서 변경할 수 없습니다(SYSDBA 또는 사용자 본인만 변경 가능)",
|
||
inheritedFrom: "{via}에서 상속됨",
|
||
userType: "사용자 유형",
|
||
userTypeHint: "관리 사용자는 DBA, 감사 사용자는 DB_AUDIT_ADMIN, 보안 사용자는 DB_POLICY_ADMIN을 자동 부여합니다",
|
||
groupOther: "기타 사용자",
|
||
systemUserProtected: "시스템 사용자는 수정하거나 삭제할 수 없습니다",
|
||
builtinRole: "내장 역할",
|
||
builtinRoleProtected: "내장 역할은 회수할 수 없습니다",
|
||
defaultTablespace: "기본 테이블스페이스",
|
||
created: "생성 시간",
|
||
lock: "잠금",
|
||
unlock: "잠금 해제",
|
||
dropUser: "사용자 삭제",
|
||
roles: "역할",
|
||
systemPrivileges: "시스템 권한",
|
||
grantedRoles: "부여된 역할",
|
||
grantedPrivileges: "부여된 권한",
|
||
grantRole: "역할 부여",
|
||
revokeRole: "역할 회수",
|
||
roleToGrant: "부여할 역할",
|
||
selectRole: "역할 선택",
|
||
grantRoleHint: "사용자 {user}에게 역할을 부여합니다.",
|
||
noRolesToGrant: "부여할 수 있는 역할이 없습니다",
|
||
noGrantedRoles: "이 사용자에게 부여된 역할이 없습니다",
|
||
grantPrivilege: "권한 부여",
|
||
revokePrivilege: "권한 회수",
|
||
privilegeToGrant: "부여할 권한",
|
||
selectPrivilege: "권한 선택",
|
||
grantPrivilegeHint: "사용자 {user}에게 시스템 권한을 부여합니다.",
|
||
noPrivilegesToGrant: "부여할 수 있는 권한이 없습니다",
|
||
noGrantedPrivileges: "이 사용자에게 부여된 시스템 권한이 없습니다",
|
||
previewSql: "SQL 미리보기",
|
||
sqlPreview: "SQL 미리보기",
|
||
applySql: "SQL 실행",
|
||
applySuccess: "사용자 작업이 실행되었습니다",
|
||
applyFailed: "실행 실패: {message}",
|
||
enableDdlAnyPrivHint: "힌트: DM8은 기본적으로 DDL ANY 권한 부여를 비활성화합니다(ENABLE_DDL_ANY_PRIV=0). ANY 권한을 부여하려면 SYSDBA로 실행: sp_set_para_value(1,'ENABLE_DDL_ANY_PRIV',1). ANY가 아닌 권한은 현재 계정에 해당 권한의 ADMIN OPTION이 있어야 합니다.",
|
||
anyPrivilegeDisabled: "ANY 유형 권한은 DM8에서 비활성화되어(ENABLE_DDL_ANY_PRIV=0) 부여하거나 회수할 수 없습니다",
|
||
},
|
||
damengRoleAdmin: {
|
||
title: "Dameng 역할",
|
||
unsupported: "이 페이지는 Dameng 데이터베이스 연결만 지원합니다.",
|
||
newRole: "새 역할",
|
||
searchRole: "역할 검색",
|
||
loadFailed: "불러오기 실패",
|
||
emptyRoles: "역할이 없거나 현재 계정에 역할 목록을 읽을 권한이 없습니다.",
|
||
selectRole: "역할을 선택하세요",
|
||
roleName: "역할 이름",
|
||
roleNamePlaceholder: "예: APP_ROLE",
|
||
members: "멤버",
|
||
systemPrivileges: "시스템 권한",
|
||
grantedToUsers: "이 역할이 부여된 사용자",
|
||
grantedPrivileges: "부여된 권한",
|
||
noMembers: "이 역할이 부여된 사용자가 없습니다",
|
||
grantToUser: "사용자에게 부여",
|
||
userToGrant: "부여할 사용자",
|
||
selectUser: "사용자 선택",
|
||
grantUserHint: "역할 {role}을 사용자에게 부여합니다.",
|
||
noUsersToGrant: "부여할 수 있는 사용자가 없습니다",
|
||
revokeFromUser: "회수",
|
||
systemUser: "시스템 사용자",
|
||
systemUserProtected: "시스템 사용자에게서는 회수할 수 없습니다",
|
||
builtinRole: "내장 역할",
|
||
builtinRoleProtected: "미리 정의된 역할은 삭제하거나 수정할 수 없습니다",
|
||
grantPrivilege: "권한 부여",
|
||
revokePrivilege: "권한 회수",
|
||
privilegeToGrant: "부여할 권한",
|
||
selectPrivilege: "권한 선택",
|
||
grantPrivilegeHint: "역할 {role}에 시스템 권한을 부여합니다.",
|
||
noPrivilegesToGrant: "부여할 수 있는 권한이 없습니다",
|
||
noGrantedPrivileges: "이 역할에 부여된 시스템 권한이 없습니다",
|
||
dropRole: "역할 삭제",
|
||
previewSql: "SQL 미리보기",
|
||
sqlPreview: "SQL 미리보기",
|
||
applySql: "SQL 실행",
|
||
applySuccess: "역할 작업이 실행되었습니다",
|
||
applyFailed: "실행 실패: {message}",
|
||
enableDdlAnyPrivHint: "힌트: DM8은 기본적으로 DDL ANY 권한 부여를 비활성화합니다(ENABLE_DDL_ANY_PRIV=0). ANY 권한을 부여하려면 SYSDBA로 실행: sp_set_para_value(1,'ENABLE_DDL_ANY_PRIV',1). ANY가 아닌 권한은 현재 계정에 해당 권한의 ADMIN OPTION이 있어야 합니다.",
|
||
anyPrivilegeDisabled: "ANY 유형 권한은 DM8에서 비활성화되어(ENABLE_DDL_ANY_PRIV=0) 부여하거나 회수할 수 없습니다",
|
||
},
|
||
objects: {
|
||
all: "전체",
|
||
tables: "테이블",
|
||
collections: "컬렉션",
|
||
views: "뷰",
|
||
procedures: "프로시저",
|
||
functions: "함수",
|
||
sequences: "시퀀스",
|
||
packages: "패키지",
|
||
table: "테이블",
|
||
collection: "컬렉션",
|
||
partitions: "파티션 {count}개",
|
||
view: "뷰",
|
||
timeseries: "시계열",
|
||
procedure: "프로시저",
|
||
function: "함수",
|
||
trigger: "트리거",
|
||
sequence: "시퀀스",
|
||
package: "패키지",
|
||
packageBody: "패키지 본문",
|
||
typeDefinition: "타입",
|
||
typeBody: "타입 본문",
|
||
name: "이름",
|
||
type: "유형",
|
||
rows: "행",
|
||
series: "시계열 수",
|
||
size: "크기",
|
||
statisticsHint: "데이터베이스 통계에서 추정한 값이며, COUNT(*)는 실행되지 않습니다.",
|
||
createdAt: "생성일",
|
||
updatedAt: "수정일",
|
||
source: "소스",
|
||
saveSource: "저장",
|
||
cancelEdit: "취소",
|
||
sourceSaved: "소스를 저장했습니다",
|
||
sourceSaveFailed: "소스 저장에 실패했습니다: {message}",
|
||
postgresViewColumnChangeHint:
|
||
"PostgreSQL은 CREATE OR REPLACE VIEW로 기존 뷰 컬럼을 제거, 재정렬, 이름 변경 또는 타입 변경할 수 없습니다. 기존 컬럼 수, 순서, 이름, 타입은 그대로 유지하고 새 컬럼은 끝에만 추가할 수 있습니다. 컬럼 이름을 바꾸려면 ALTER VIEW ... RENAME COLUMN을 사용하세요. 컬럼을 제거하려면 종속성을 검토하고 뷰를 수동으로 다시 만드세요.",
|
||
sourceReadOnly: "이 소스는 읽기 전용이며 편집할 수 없습니다.",
|
||
schemaColumn: "스키마",
|
||
comment: "주석",
|
||
loadingSchemas: "스키마를 불러오는 중...",
|
||
schema: "스키마",
|
||
search: "테이블, 뷰, 함수, 시퀀스 또는 프로시저 검색...",
|
||
searchCollections: "컬렉션 검색...",
|
||
loading: "객체를 불러오는 중...",
|
||
empty: "객체가 없습니다",
|
||
selectedTables: "테이블 {count}개 선택됨",
|
||
exportSelected: "선택 항목 내보내기",
|
||
dropSelected: "선택 항목 삭제",
|
||
truncateSelected: "선택 항목 비우기",
|
||
clearSelection: "선택 해제",
|
||
confirmBatchDropTitle: "선택한 테이블 삭제",
|
||
confirmBatchDropMessage: "선택한 테이블 {count}개를 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.",
|
||
confirmBatchTruncateTitle: "선택한 테이블 비우기",
|
||
confirmBatchTruncateMessage: "선택한 테이블 {count}개를 비우시겠습니까? 모든 행이 제거됩니다.",
|
||
batchDropSuccess: "테이블 {count}개 삭제",
|
||
batchTruncateSuccess: "테이블 {count}개 비움",
|
||
copyTableSelected: "복사",
|
||
pasteTableSelected: "붙여넣기",
|
||
toggleCheckbox: "다중 선택 전환",
|
||
viewList: "목록 보기",
|
||
viewGrid: "표 보기",
|
||
sortAsc: "오름차순",
|
||
sortDesc: "내림차순",
|
||
sortBy: "정렬 기준",
|
||
},
|
||
structureEditor: {
|
||
title: "테이블 구조 편집",
|
||
createTitle: "테이블 만들기",
|
||
editTabTitle: "편집: {tableName}",
|
||
tableName: "테이블 이름",
|
||
refresh: "구조 새로고침",
|
||
density: "행 간격",
|
||
densityCompact: "좁게",
|
||
densityStandard: "표준",
|
||
densityComfortable: "넓게",
|
||
columns: "컬럼",
|
||
indexes: "인덱스",
|
||
foreignKeys: "외래 키",
|
||
constraints: "제약 조건",
|
||
constraintDisabled: "비활성화됨",
|
||
constraintNotValidated: "검증되지 않음",
|
||
triggers: "트리거",
|
||
ddl: "DDL",
|
||
addColumn: "컬럼 추가",
|
||
copyColumns: "다른 테이블에서 필드 복사",
|
||
copyColumn: "컬럼 복사",
|
||
copyColumnsTitle: "다른 테이블에서 컬럼 복사",
|
||
copyColumnsSourceTable: "원본 테이블",
|
||
copyColumnsSearchSourceTables: "원본 테이블 검색",
|
||
copyColumnsSelectFields: "필드 선택",
|
||
copyColumnsSearchFields: "필드 또는 유형 검색",
|
||
copyColumnsSelectAll: "모두 선택",
|
||
copyColumnsClearSelection: "선택 해제",
|
||
copyColumnsNoSourceTables: "이 스키마에 선택할 수 있는 다른 테이블이 없습니다.",
|
||
copyColumnsNoMatchingSourceTables: "검색과 일치하는 원본 테이블이 없습니다.",
|
||
copyColumnsPreviousSourceTablePage: "원본 테이블 이전 페이지",
|
||
copyColumnsNextSourceTablePage: "원본 테이블 다음 페이지",
|
||
copyColumnsNoFields: "선택한 테이블에 필드가 없습니다.",
|
||
copyColumnsNoMatchingFields: "검색과 일치하는 필드가 없습니다.",
|
||
copyColumnsAlreadyExists: "이미 존재함",
|
||
copyColumnsCancel: "취소",
|
||
copyColumnsApply: "{count}개 필드 복사",
|
||
columnTemplates: "미리 정의된 필드 삽입",
|
||
configureColumnTemplates: "미리 정의된 필드 설정",
|
||
presetFieldsTemplate: "미리 정의된 필드 세트",
|
||
searchColumns: "컬럼/주석 검색",
|
||
nextColumnMatch: "다음 일치 컬럼으로 이동",
|
||
searchIndexes: "인덱스 검색",
|
||
nextIndexMatch: "다음 일치 인덱스로 이동",
|
||
addIndex: "인덱스 추가",
|
||
addForeignKey: "외래 키 추가",
|
||
addTrigger: "트리거 추가",
|
||
columnName: "컬럼",
|
||
dataType: "타입",
|
||
typePlaceholder: "선택 또는 입력...",
|
||
noMatchingType: "일치하는 타입 없음",
|
||
mysqlDataTypeHelp: {
|
||
tinyint: "1바이트 정수. 부호 있음: -128 ~ 127, 부호 없음: 0 ~ 255.",
|
||
smallint: "2바이트 정수. 부호 있음: -32,768 ~ 32,767, 부호 없음: 0 ~ 65,535.",
|
||
mediumint: "3바이트 정수. 부호 있음: -8,388,608 ~ 8,388,607, 부호 없음: 0 ~ 16,777,215.",
|
||
int: "4바이트 정수. 부호 있음: -2,147,483,648 ~ 2,147,483,647, 부호 없음: 0 ~ 4,294,967,295.",
|
||
bigint: "8바이트 정수. 부호 있음: -2^63 ~ 2^63-1, 부호 없음: 0 ~ 2^64-1.",
|
||
decimal: "정확한 고정소수점 숫자. MySQL은 정밀도 최대 65자리, 스케일 최대 30자리를 지원하며 MariaDB 버전 한도는 다를 수 있습니다. 금액 등 정확한 값에 사용하세요.",
|
||
float: "단정밀도 근사 숫자. 정확한 소수 값이 필요할 때는 DECIMAL을 사용하세요.",
|
||
double: "배정밀도 근사 숫자. 정확한 소수 값이 필요할 때는 DECIMAL을 사용하세요.",
|
||
real: "기본적으로 DOUBLE의 별칭. REAL_AS_FLOAT SQL 모드에서는 FLOAT의 별칭이 됩니다.",
|
||
bit: "1~64비트 비트 필드. 기본 너비는 1비트입니다.",
|
||
boolean: "TINYINT(1)의 별칭. 0은 거짓, 0이 아닌 값은 참을 나타냅니다.",
|
||
serial: "BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE의 편의 별칭.",
|
||
date: "달력 날짜. 지원 범위: 1000-01-01 ~ 9999-12-31.",
|
||
datetime: "시간대 변환 없는 날짜와 시간. 지원 범위: 1000-01-01 00:00:00 ~ 9999-12-31 23:59:59, 소수초 정밀도 0~6(기본 0).",
|
||
timestamp: "세션 시간대와 UTC 간에 변환되는 날짜와 시간. 지원 범위: 1970-01-01 00:00:01 UTC ~ 2038-01-19 03:14:07 UTC, 소수초 정밀도 0~6(기본 0).",
|
||
time: "하루 중의 시간 또는 경과 시간. 지원 범위: -838:59:59 ~ 838:59:59, 소수초 정밀도 0~6(기본 0).",
|
||
year: "연도 값. 4자리 값의 범위는 1901 ~ 2155, 추가로 0000.",
|
||
char: "고정 길이 문자열, 최대 255자. 저장된 값은 공백으로 우측 채움됩니다.",
|
||
varchar: "가변 길이 문자열. 실제 최댓값은 행 크기와 문자 집합의 제약을 받습니다.",
|
||
tinytext: "가변 길이 텍스트, 최대 255바이트. 문자 집합, 행 크기, max_allowed_packet 제한으로 실제 한도가 더 낮을 수 있습니다.",
|
||
text: "가변 길이 텍스트, 최대 65,535바이트. 문자 집합, 행 크기, max_allowed_packet 제한으로 실제 한도가 더 낮을 수 있습니다.",
|
||
mediumtext: "가변 길이 텍스트, 최대 16,777,215바이트. 문자 집합, 행 크기, max_allowed_packet 제한으로 실제 한도가 더 낮을 수 있습니다.",
|
||
longtext: "가변 길이 텍스트, 최대 4,294,967,295바이트(약 4GiB). 문자 집합, 행 크기, max_allowed_packet 제한으로 실제 한도가 더 낮을 수 있습니다.",
|
||
binary: "고정 길이 바이너리 바이트 문자열, 최대 255바이트. 저장된 값은 0x00으로 채워집니다.",
|
||
varbinary: "가변 길이 바이너리 바이트 문자열. 실제 최댓값은 행 크기의 제약을 받습니다.",
|
||
tinyblob: "바이너리 대형 객체, 최대 255바이트. 행 크기와 max_allowed_packet 제한으로 실제 한도가 더 낮을 수 있습니다.",
|
||
blob: "바이너리 대형 객체, 최대 65,535바이트. 행 크기와 max_allowed_packet 제한으로 실제 한도가 더 낮을 수 있습니다.",
|
||
mediumblob: "바이너리 대형 객체, 최대 16,777,215바이트. 행 크기와 max_allowed_packet 제한으로 실제 한도가 더 낮을 수 있습니다.",
|
||
longblob: "바이너리 대형 객체, 최대 4,294,967,295바이트(약 4GiB). 행 크기와 max_allowed_packet 제한으로 실제 한도가 더 낮을 수 있습니다.",
|
||
enum: "최대 65,535개의 선언된 리터럴 중 하나의 값. 리터럴 순서를 변경하면 저장된 값의 의미가 바뀔 수 있습니다.",
|
||
set: "최대 64개의 선언된 멤버 중 0개 이상의 값.",
|
||
json: "검증된 JSON 문서. 저장 표현과 JSON 기능 지원은 연결된 서버 제품과 버전에 따라 다르며, 문서 크기 역시 max_allowed_packet의 제한을 받습니다.",
|
||
jsonMysql: "MySQL의 네이티브 바이너리 JSON 문서 타입으로 JSON 함수와 검증을 지원합니다. 문서 크기는 max_allowed_packet의 제한을 받습니다.",
|
||
jsonMariaDb: "MariaDB JSON은 JSON_VALID 제약 조건과 utf8mb4_bin 정렬을 가진 LONGTEXT의 별칭입니다. 문서 크기는 max_allowed_packet의 제한을 받습니다.",
|
||
nationalCharacter: "국가 문자열 별칭. MySQL에서는 미리 정의된 국가 문자 집합(utf8mb3, 더 이상 사용되지 않음)을 사용합니다. 새 스키마에서는 utf8mb4를 명시적으로 선택하세요.",
|
||
geometry: "지원되는 모든 지오메트리 타입의 공간 값. MySQL InnoDB SPATIAL 인덱스는 SRID 속성이 있는 NOT NULL 컬럼이 필요합니다.",
|
||
point: "하나의 좌표 쌍을 가진 공간 점. MySQL InnoDB SPATIAL 인덱스는 SRID 속성이 있는 NOT NULL 컬럼이 필요합니다.",
|
||
linestring: "하나 이상의 연결된 점으로 구성된 공간 곡선. MySQL InnoDB SPATIAL 인덱스는 SRID 속성이 있는 NOT NULL 컬럼이 필요합니다.",
|
||
polygon: "하나 이상의 고리로 둘러싸인 공간 표면. MySQL InnoDB SPATIAL 인덱스는 SRID 속성이 있는 NOT NULL 컬럼이 필요합니다.",
|
||
multipoint: "공간 점의 모음. MySQL InnoDB SPATIAL 인덱스는 SRID 속성이 있는 NOT NULL 컬럼이 필요합니다.",
|
||
multilinestring: "공간 곡선의 모음. MySQL InnoDB SPATIAL 인덱스는 SRID 속성이 있는 NOT NULL 컬럼이 필요합니다.",
|
||
multipolygon: "공간 다각형의 모음. MySQL InnoDB SPATIAL 인덱스는 SRID 속성이 있는 NOT NULL 컬럼이 필요합니다.",
|
||
geometrycollection: "혼합된 공간 지오메트리 타입을 포함할 수 있는 모음. MySQL InnoDB SPATIAL 인덱스는 SRID 속성이 있는 NOT NULL 컬럼이 필요합니다.",
|
||
inet4: "MariaDB IPv4 주소 타입(MariaDB 10.10부터). IPv4 주소를 4바이트로 저장합니다.",
|
||
inet6: "IPv6 및 매핑된 IPv4 값을 위한 MariaDB 호환 주소 타입.",
|
||
uuid: "호환 서버가 제공하는 128비트 범용 고유 식별자 타입.",
|
||
vector: "유사도 또는 머신러닝 워크로드용 벡터 데이터 타입. 가용성과 차원은 서버 버전에 따라 다릅니다.",
|
||
xmltype: "호환 서버가 제공하는 XML 데이터 타입.",
|
||
integerDisplayWidth: "MySQL 정수 표시 너비(예: INT(11))는 더 이상 사용되지 않으며 저장 범위를 제한하지 않습니다. 새 MySQL 8 스키마에 추가하지 마세요.",
|
||
zerofill: "ZEROFILL은 MySQL 8에서 더 이상 사용되지 않습니다. 또한 컬럼을 암시적으로 UNSIGNED로 만듭니다. 대신 애플리케이션에서 명시적 서식을 사용하세요.",
|
||
unsignedNumeric: "DECIMAL, FLOAT 또는 DOUBLE에 대한 UNSIGNED는 MySQL 8에서 더 이상 사용되지 않습니다. 음이 아닌 도메인이 필요할 때는 CHECK 제약 조건을 사용하세요.",
|
||
floatPrecision: "FLOAT(p)에서 p가 25~53이면 FLOAT 대신 DOUBLE 정밀도를 선택합니다. 이것이 의도된 경우 DOUBLE을 명시적으로 사용하세요.",
|
||
floatingPointDisplay: "FLOAT(M,D)와 DOUBLE(M,D)는 MySQL 8에서 더 이상 사용되지 않습니다. 표시 매개변수 없는 FLOAT/DOUBLE을 사용하거나, 정확한 값에는 DECIMAL(M,D)을 사용하세요.",
|
||
},
|
||
postgresDataTypeHelp: {
|
||
smallint: "2바이트 부호 있는 정수, -32,768 ~ 32,767.",
|
||
integer: "4바이트 부호 있는 정수, -2,147,483,648 ~ 2,147,483,647.",
|
||
bigint: "8바이트 부호 있는 정수, -2^63 ~ 2^63-1.",
|
||
serial: "정수 컬럼, 시퀀스, NOT NULL, nextval 기본값을 만드는 편의 문법. 자체로는 고유하지 않으며 시퀀스 값에 빈칸이 있을 수 있습니다. 새 스키마에는 IDENTITY를 권장합니다.",
|
||
numeric: "사용자가 선택한 정밀도와 스케일을 가진 정확한 십진수. 금액 등 바이너리 부동소수점 반올림을 사용하지 말아야 할 값에 사용하세요.",
|
||
real: "4바이트 단정밀도 부동소수점 숫자. FLOAT(p)에서 p가 1~24이면 이 타입을 선택합니다.",
|
||
double: "8바이트 배정밀도 부동소수점 숫자. 정밀도 없는 FLOAT이 별칭이며, FLOAT(p)에서 p가 25~53이면 이 타입을 선택합니다.",
|
||
money: "로케일 서식의 통화 금액. 출력과 파싱은 lc_monetary에 따라 달라지며, 이식 가능한 재무 데이터에는 NUMERIC이 일반적으로 더 안전합니다.",
|
||
boolean: "참, 거짓 또는 null 값. BOOL은 BOOLEAN의 별칭입니다.",
|
||
char: "고정 길이 공백 채움 문자열. CHARACTER는 별칭이며, 후행 공백이 의미를 가질 때는 피하세요.",
|
||
varchar: "선택적 문자 제한이 있는 가변 길이 문자열. CHARACTER VARYING은 별칭입니다.",
|
||
text: "선언된 제한 없는 가변 길이 문자열. 제한 없는 VARCHAR과 동일한 저장 동작을 가집니다.",
|
||
bytea: "가변 길이 바이너리 문자열. 큰 값은 TOAST로 라인 외부에 저장될 수 있습니다.",
|
||
date: "시간이나 시간대 없는 달력 날짜.",
|
||
time: "시간대 없는 하루 중의 시간, 선택적 소수초 정밀도.",
|
||
timetz: "하루 중의 시간에 UTC 오프셋을 더한 값. 유용성이 제한적이며 일반적으로 권장하지 않습니다. 특정 시점에는 timestamptz를 사용하세요.",
|
||
timestamp: "시간대 변환 없는 날짜와 시간. 시간대가 데이터의 일부가 아닌 로컬 벽시계 값에 사용하세요.",
|
||
timestamptz: "내부적으로 UTC로 저장되고 세션 시간대로 표시되는 특정 시점. 원래 명명된 시간대는 유지하지 않습니다.",
|
||
interval: "월, 일, 마이크로초로 표현된 기간. 달력 단위는 고정 길이 기간이 아닙니다.",
|
||
uuid: "128비트 범용 고유 식별자.",
|
||
json: "원래 입력 표현으로 보존된 JSON 텍스트. 파싱은 검증되지만 처리는 일반적으로 JSONB보다 느립니다.",
|
||
jsonb: "처리와 인덱싱에 최적화된 분해된 바이너리 JSON 표현. 의미 없는 공백, 키 순서 또는 중복 키를 보존하지 않습니다.",
|
||
xml: "사용된 XML 옵션에 따라 선택적 문서 또는 콘텐츠 검증을 가진 XML 값.",
|
||
bit: "고정 또는 가변 길이 비트 문자열. BIT VARYING과 VARBIT는 가변 길이 별칭입니다.",
|
||
tsvector: "PostgreSQL 전문 검색의 검색 가능한 문서 측으로 사용되는 정규화된 어휘소이며, 일반적으로 GIN 또는 GiST로 인덱싱됩니다.",
|
||
tsquery: "tsvector에 대해 평가되는 불리언 전문 검색 쿼리.",
|
||
cidr: "호스트 비트가 0으로 제한된 IPv4 또는 IPv6 네트워크.",
|
||
inet: "선택적으로 네트워크 마스크가 있는 IPv4 또는 IPv6 호스트 주소. CIDR과 달리 호스트 비트가 0이 아닐 수 있습니다.",
|
||
macaddr: "MAC 주소. MACADDR은 6바이트 주소를, MACADDR8은 8바이트 주소를 저장합니다.",
|
||
geometry: "내장 2차원 기하 타입. PostgreSQL 지오메트리는 평면적이며 SRID가 없습니다. 지리적 좌표, 투영 또는 고급 공간 작업에는 PostGIS를 사용하세요.",
|
||
range: "포함/제외 경계를 가진 단일 연속 범위. 범위 값에는 호환되는 하위 타입이 필요하며, 여러 분리된 범위에는 multirange 타입을 사용하세요.",
|
||
oid: "부호 없는 객체 식별자. 시스템 식별자이며 영구적인 애플리케이션 기본 키가 아닙니다. 애플리케이션 데이터에는 일반 정수 또는 UUID를 사용하세요.",
|
||
array: "다차원 배열을 포함한 모든 요소 타입의 PostgreSQL 배열. 배열 차원은 선언된 타입으로 강제되지 않으며, 배열은 정규화된 하위 행보다 유연성이 떨어지는 경우가 많습니다.",
|
||
multirange: "일치하는 범위 하위 타입의 겹치지 않는 범위 집합. PostgreSQL은 하위 타입 규칙에 따라 인접하거나 겹치는 멤버를 정규화합니다.",
|
||
jsonpath: "JSONB 쿼리와 술어 함수에서 사용되는 SQL/JSON 경로 표현식.",
|
||
pgLsn: "복제 및 복구 좌표에 사용되는 사전 로그(WAL) 위치이며, 애플리케이션 시퀀스 번호가 아닙니다.",
|
||
pgSnapshot: "트랜잭션 가시성 스냅샷. 텍스트 표현은 데이터베이스 스냅샷 작업을 위한 것이지 일반적인 애플리케이션 데이터용이 아닙니다.",
|
||
},
|
||
sqliteDataTypeHelp: {
|
||
integer: "SQLite는 동적 타이핑과 INTEGER 선호도를 사용하며, 일반 컬럼은 INTEGER 저장 클래스를 강제하지 않습니다. 가능한 경우 값은 부호 있는 정수로 저장되며, INTEGER PRIMARY KEY(정확한 철자)는 rowid의 특별한 별칭입니다.",
|
||
real: "REAL 선호도는 IEEE 754 부동소수점 값을 저장합니다. 근사 측정에 적합하며 정확한 금액이나 십진 계산에는 적합하지 않습니다.",
|
||
text: "TEXT 선호도는 데이터베이스 인코딩으로 텍스트를 저장합니다. SQLite에서 VARCHAR(n)과 CHAR(n)은 n을 강제하지 않으며, 길이 제한이 중요할 때 CHECK 제약 조건을 추가하세요.",
|
||
blob: "BLOB 선호도는 타입 변환 없이 제공된 바이트를 그대로 저장합니다.",
|
||
numeric: "NUMERIC 선호도는 올바른 형식의 숫자 텍스트를 먼저 INTEGER로, 그 다음 REAL로 변환을 시도하며, 별도의 SQLite 저장 클래스가 아닙니다. DATE, DATETIME, TIME 선언 역시 NUMERIC 선호도를 가지며, ISO-8601 TEXT, 율리우스일 REAL 또는 Unix 시간 INTEGER를 일관되게 사용하세요.",
|
||
},
|
||
length: "길이",
|
||
lengthUnit: "길이 단위",
|
||
unitPlaceholder: "단위",
|
||
geometryTypePlaceholder: "지오메트리 유형을 선택하거나 입력",
|
||
sridPlaceholder: "예: 4326",
|
||
geometrySridHint: "공간 인덱싱과 정확한 공간 쿼리를 사용하려면 지오메트리 유형과 SRID를 지정하세요.",
|
||
geometryEmptyTypeHint: "지오메트리 유형을 비우면 GEOMETRY(임의 하위 유형)와 같으며, geometry(GEOMETRY, SRID)가 생성됩니다.",
|
||
enumValues: "Enum 값",
|
||
enumValueCount: "{count}개 값",
|
||
addEnumValue: "값 추가",
|
||
removeEnumValue: "Enum 값 제거",
|
||
enumValuePlaceholder: "값 (비워도 됨)",
|
||
nullable: "NULL 허용",
|
||
primaryKey: "기본 키",
|
||
defaultValue: "기본값",
|
||
defaultValuePresets: "기본값 프리셋",
|
||
comment: "주석",
|
||
characterSet: "문자셋",
|
||
charsetPlaceholder: "문자셋",
|
||
collation: "정렬",
|
||
collationPlaceholder: "정렬",
|
||
editComment: "주석 편집",
|
||
commentPlaceholder: "컬럼 주석 입력...",
|
||
tableCommentPlaceholder: "테이블 주석 입력...",
|
||
owner: "소유자",
|
||
ownerPlaceholder: "역할 이름 입력...",
|
||
ownerSearchPlaceholder: "역할 이름 검색 또는 입력...",
|
||
ownerRolesEmpty: "역할을 찾을 수 없습니다. 역할 이름을 직접 입력할 수 있습니다",
|
||
ownerLoadFailed: "테이블 소유자를 불러오지 못했습니다: {message}",
|
||
ownerRolesLoadFailed: "역할 목록을 불러오지 못했습니다. 직접 입력할 수 있습니다: {message}",
|
||
tableCommentUnsupported: "이 데이터베이스는 테이블 주석을 지원하지 않습니다",
|
||
actions: "작업",
|
||
indexName: "인덱스",
|
||
indexColumns: "컬럼",
|
||
indexColumnsPlaceholder: "컬럼 선택...",
|
||
unique: "고유",
|
||
indexType: "타입",
|
||
includedColumns: "포함",
|
||
includedColumnsPlaceholder: "컬럼 선택...",
|
||
filter: "필터",
|
||
concurrent: "동시 생성",
|
||
concurrentTooltip: "쓰기 차단을 피하기 위해 인덱스를 동시에 생성합니다. 일반적으로 더 오래 걸리며 트랜잭션 블록 내에서 실행할 수 없습니다.",
|
||
concurrentExistingIndexTooltip: "새 인덱스에서만 사용할 수 있습니다. 기존 인덱스의 동시 재구축(DROP INDEX CONCURRENTLY + CREATE INDEX CONCURRENTLY)은 아직 지원되지 않습니다.",
|
||
concurrentPartitionedTooltip: "파티션 부모 테이블에서는 사용할 수 없습니다. PostgreSQL은 파티션 부모 테이블에서의 동시 인덱스 생성을 거부합니다. 하위 인덱스를 동시에 생성한 후 연결하세요.",
|
||
invalidIndexBlocksSave: '저장이 차단되었습니다: 취소된 동시 빌드가 남긴 같은 이름의 INVALID 인덱스가 이미 존재합니다: {indexNames}. 먼저 삭제(예: DROP INDEX "schema"."name")한 후 다시 시도하세요.',
|
||
concurrentUnavailableTooltip: "테이블의 파티션 상태를 확인할 수 없는 동안에는 사용할 수 없습니다. 동시 생성은 파티션이 아닌 테이블에서만 제공됩니다.",
|
||
concurrentUnavailableBlocksSave: "인덱스 동시 생성은 더 이상 사용할 수 없습니다(테이블의 파티션 상태를 확인할 수 없습니다). 선택한 동시 옵션이 해제되었으며 테이블이 다시 확인될 때까지 이 변경은 차단됩니다. 다시 시도하려면 새로 고치거나 다른 변경을 계속하려면 인덱스를 제거하세요.",
|
||
invalidIndexRetryHint: "이전에 취소된 동시 빌드가 남긴 같은 이름의 INVALID 인덱스 때문일 수 있습니다. 해당 인덱스를 먼저 삭제한 후 다시 시도하세요.",
|
||
foreignKeyName: "외래 키",
|
||
referencedSchema: "참조 스키마",
|
||
referencedTable: "참조 테이블",
|
||
referencedColumn: "참조 컬럼",
|
||
onDelete: "삭제 시",
|
||
onUpdate: "수정 시",
|
||
defaultAction: "기본",
|
||
triggerName: "트리거",
|
||
triggerStatement: "트리거 구문",
|
||
primary: "기본",
|
||
drop: "삭제",
|
||
restore: "복원",
|
||
remove: "제거",
|
||
moveColumnUp: "컬럼을 위로 이동",
|
||
copySelectedColumns: "선택한 필드 복사 ({count})",
|
||
dropSelectedColumns: "선택한 필드 삭제 ({count})",
|
||
moveColumnDown: "컬럼을 아래로 이동",
|
||
dragColumn: "드래그하여 컬럼 순서 변경",
|
||
localColumnOrderNotice: "컬럼 순서는 로컬에만 저장되며 데이터베이스 테이블 구조를 변경하지 않습니다.",
|
||
yes: "예",
|
||
no: "아니오",
|
||
emptyReadonly: "레코드가 없습니다",
|
||
sqlPreview: "SQL 미리보기",
|
||
collapseSqlPreview: "SQL 미리보기 접기",
|
||
expandSqlPreview: "SQL 미리보기 펼치기",
|
||
noChanges: "변경 사항 없음",
|
||
apply: "변경 사항 적용",
|
||
ready: "준비됨",
|
||
saved: "테이블 구조가 업데이트되었습니다",
|
||
copySql: "SQL 복사",
|
||
sqliteRebuildNotice: "SQLite는 백업으로 비활성 데이터 스냅샷을 유지한 다음 하나의 트랜잭션에서 테이블을 재구성하고 변경된 컬럼을 강제로 CAST합니다. 표현할 수 없는 값은 0/0.0이 될 수 있으며, 실패 시 롤백됩니다.",
|
||
ddlEditNotice: "편집한 DDL은 작성한 그대로 스크립트로 실행되며 현재 구조와 비교되지 않습니다. 기존 테이블에는 ALTER(또는 DROP + CREATE) 문으로 직접 다시 작성하세요.",
|
||
ddlEditConflictsWithStructure: "DDL 스크립트와 구조 탭이 모두 편집되었습니다. 저장하기 전에 둘 중 하나를 적용하거나 취소하세요.",
|
||
resetDdl: "데이터베이스 DDL 복원",
|
||
extendedProperties: "확장",
|
||
autoIncrement: "자동 증가",
|
||
mysqlAutoIncrementNextValue: "다음 자동 증가 값",
|
||
editMysqlAutoIncrementValue: "다음 자동 증가 값 편집(현재: {value})",
|
||
onUpdateCurrentTimestamp: "수정 시간 자동 갱신",
|
||
identity: "ID",
|
||
identityGeneration: "생성",
|
||
identitySeed: "시드",
|
||
identityIncrement: "증가분",
|
||
sqlServerIdentityTypeHint: "SQL Server ID는 tinyint, smallint, int, bigint 및 스케일이 0인 decimal/numeric만 지원합니다",
|
||
},
|
||
diagram: {
|
||
title: "관계 다이어그램",
|
||
open: "다이어그램 보기",
|
||
selectConnection: "연결 선택",
|
||
selectDatabase: "데이터베이스 선택",
|
||
selectSchema: "스키마 선택",
|
||
allSchemas: "전체 데이터베이스(모든 스키마)",
|
||
entireDatabase: "전체 데이터베이스",
|
||
selectedSchemasCount: "스키마 {count}개 선택됨",
|
||
selectAllSchemas: "모든 스키마 선택",
|
||
deselectAllSchemas: "선택 지우기",
|
||
onlyThisSchema: "이 스키마만",
|
||
searchSchemas: "스키마 검색...",
|
||
searchTables: "테이블, 컬럼, 키 검색...",
|
||
refresh: "다이어그램 새로고침",
|
||
loading: "관계를 읽는 중...",
|
||
loadingProgress: "관계를 읽는 중... {loaded}/{total}",
|
||
partialError: "불러오는 데 실패한 {count}개 테이블의 메타데이터를 건너뛰었습니다",
|
||
selectTarget: "연결과 데이터베이스를 선택하세요",
|
||
empty: "표시할 테이블이 없습니다",
|
||
noMatches: "일치하는 테이블이 없습니다",
|
||
tablesCount: "테이블 {count}개",
|
||
relationshipsCount: "관계 {count}개",
|
||
tableMode: "테이블 보기",
|
||
engineeringMode: "엔지니어링 ER",
|
||
modelRelationships: "관계 모델링",
|
||
copyJoinSql: "SQL 복사",
|
||
customRelationshipsCount: "{count}개 모델링됨",
|
||
relationshipName: "이름",
|
||
relationshipNamePlaceholder: "선택",
|
||
sourceTable: "소스 테이블",
|
||
sourceColumn: "소스 컬럼",
|
||
targetTable: "대상 테이블",
|
||
targetColumn: "대상 컬럼",
|
||
cardinality: "카디널리티",
|
||
cardinalityOneToMany: "1:N",
|
||
cardinalityManyToOne: "N:1",
|
||
cardinalityManyToMany: "N:N",
|
||
cardinalityOneToOne: "1:1",
|
||
addRelationship: "관계 추가",
|
||
removeRelationship: "관계 제거",
|
||
relationshipIncomplete: "소스와 대상 컬럼을 모두 선택하세요",
|
||
relationshipSelfInvalid: "관계는 같은 컬럼을 가리킬 수 없습니다",
|
||
relationshipExists: "이 관계는 이미 존재합니다",
|
||
relationshipAdded: "관계를 추가했습니다",
|
||
noJoinSql: "복사할 관계 SQL이 없습니다",
|
||
allTables: "모든 테이블",
|
||
relatedTables: "관련 테이블",
|
||
moreColumns: "컬럼 {count}개 더",
|
||
exportSvg: "SVG 내보내기",
|
||
exportedSvg: "SVG를 내보냈습니다",
|
||
exportSvgFailed: "SVG 내보내기에 실패했습니다: {message}",
|
||
zoomIn: "확대",
|
||
zoomOut: "축소",
|
||
resetLayout: "레이아웃 초기화",
|
||
},
|
||
etcd: {
|
||
prefixPlaceholder: "키 경로 검색, 예: /app/ 또는 service",
|
||
newKey: "새 키",
|
||
loadingKeys: "키를 불러오는 중...",
|
||
empty: "키가 없습니다",
|
||
loadMore: "더 불러오기",
|
||
selectKey: "값을 보려면 키를 선택하세요",
|
||
loadingValue: "값을 불러오는 중...",
|
||
notFound: "키를 찾을 수 없습니다",
|
||
edit: "편집",
|
||
editKey: "키 편집",
|
||
delete: "삭제",
|
||
deleteTitle: "etcd 키 삭제",
|
||
keyPlaceholder: "/path/to/key",
|
||
keyRequired: "키는 필수입니다",
|
||
ttl: "TTL (초)",
|
||
ttlPlaceholder: "양의 정수(초)를 입력하세요",
|
||
ttlInvalid: "TTL은 양의 정수여야 합니다",
|
||
ttlUnavailable: "TTL을 구성하려면 etcd Agent를 업데이트하고 다시 연결하세요.",
|
||
expiryMode: "만료 정책",
|
||
expiryPermanent: "영구",
|
||
expiryPermanentHint: "리스를 연결하지 않으며 키가 자동으로 만료되지 않습니다",
|
||
expiryTtl: "생존 시간 (TTL)",
|
||
expiryTtlHint: "구성된 기간 후에 만료되는 임시 리스를 만듭니다",
|
||
expiryLease: "리스 연결",
|
||
expiryLeaseHint: "키를 기존 Lease ID에 연결합니다",
|
||
leaseId: "Lease ID",
|
||
leasePlaceholder: "기존 Lease ID 입력",
|
||
leaseInvalid: "Lease ID는 올바른 양의 64비트 정수여야 합니다",
|
||
valueContent: "값 내용",
|
||
keyAlreadyExists: "이 이름의 키가 이미 존재합니다. 다른 이름을 선택하거나 이 대화상자를 닫고 기존 키를 편집하세요.",
|
||
conflict: "이 키가 불러온 후 변경되었습니다. 새로고침 후 다시 시도하세요.",
|
||
saved: "키를 저장했습니다",
|
||
deleted: "키를 삭제했습니다",
|
||
base64Readonly: "Base64 값은 Base64 모드에서 편집하세요.",
|
||
rename: "이름 변경",
|
||
clone: "복제",
|
||
copyKey: "키 복사",
|
||
export: "내보내기",
|
||
import: "가져오기",
|
||
sync: "동기화",
|
||
history: "기록",
|
||
restore: "이 버전으로 복원",
|
||
compare: "비교",
|
||
format: "값 형식",
|
||
savePreview: "값 변경 검토",
|
||
globalSearch: "전역 검색",
|
||
searchPrefix: "접두사로 제한 (선택)",
|
||
searchAll: "키와 값",
|
||
searchPlaceholder: "키 또는 값 내용 검색",
|
||
searchProgress: "{scanned}개 키 스캔, {matched}개 일치",
|
||
exportResults: "결과 내보내기",
|
||
exported: "키 {count}개 내보냄",
|
||
exportAll: "전체 내보내기",
|
||
exportSelection: "선택 항목 내보내기",
|
||
batchExport: "일괄 내보내기",
|
||
exportAllJson: "전체 내보내기 (JSON, 가져오기 가능)",
|
||
exportAllCsv: "전체 내보내기 (CSV)",
|
||
exportAllMarkdown: "전체 내보내기 (Markdown)",
|
||
exportSelectionJson: "선택 항목 내보내기 (JSON)",
|
||
exportSelectionCsv: "선택 항목 내보내기 (CSV)",
|
||
exportSelectionMarkdown: "선택 항목 내보내기 (Markdown)",
|
||
selectAllLoaded: "전체 선택",
|
||
deselectAll: "비우기",
|
||
batchDelete: "일괄 삭제",
|
||
batchDeleteTitle: "선택한 etcd 키 삭제",
|
||
batchDeleteConfirm: "선택한 키 {count}개를 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.",
|
||
batchDeleteSuccess: "키 {count}개를 삭제했습니다",
|
||
batchDeletePartial: "일괄 작업이 중지되기 전에 키 {count}개를 삭제했습니다: {error}",
|
||
importPreview: "가져오기 미리보기",
|
||
syncPreview: "동기화 미리보기",
|
||
targetConnection: "대상 etcd 연결 선택",
|
||
targetReadOnly: "대상 연결이 읽기 전용이며 가져오기와 동기화 작업을 적용할 수 없습니다.",
|
||
mirrorDelete: "추가 대상 키 삭제 (미러)",
|
||
mirrorDeleteWarning: "미러 모드는 소스에 없는 대상 키를 삭제합니다. 적용 전에 모든 삭제 작업을 검토하세요.",
|
||
preparingPreview: "고정 리비전 변경 미리보기를 준비하는 중...",
|
||
operation: "작업",
|
||
reason: "사유",
|
||
selectedOperations: "{count}개 작업 선택됨",
|
||
applyOperations: "작업 적용",
|
||
transferApplied: "{count}개 작업 적용됨",
|
||
operationApplied: "성공적으로 적용됨",
|
||
transferPartiallyApplied: "일괄 작업이 중지되기 전에 {count}개 작업이 적용되었습니다: {error}. 미리보기를 새로고침했습니다. 남은 선택 작업만 다시 시도하세요.",
|
||
transferPartialRefreshFailed: "일괄 작업이 중지되기 전에 {count}개 작업이 적용되었습니다: {error}. 미리보기 새로고침도 실패했습니다: {previewError}. 다시 시도하기 전에 미리보기를 닫았다가 다시 여세요.",
|
||
targetChangedDuringTransfer: "일괄 작업 실행 중 대상 연결이 변경되었습니다",
|
||
dashboard: {
|
||
title: "etcd 대시보드",
|
||
description: "클라이언트가 도달할 수 있는 엔드포인트 기반의 관측이며, 신뢰할 수 있는 쿼럼 상태 검사가 아닙니다.",
|
||
autoRefreshOff: "자동 새로고침 꺼짐",
|
||
refresh: "새로고침",
|
||
retry: "다시 확인",
|
||
loadFailed: "etcd 대시보드를 불러올 수 없습니다",
|
||
agentUpgradeTitle: "현재 etcd Agent에서는 대시보드를 사용할 수 없습니다",
|
||
agentUpgradeDescription: "이 연결은 클러스터 상태를 읽을 수 없는 이전 Agent를 사용 중입니다. 키 탐색과 편집은 계속 사용할 수 있습니다.",
|
||
agentUpgradeSteps: '드라이버 관리자에서 etcd Agent를 업데이트한 후 이 etcd 연결을 끊었다가 다시 연결하세요. 완료되면 "다시 확인"을 선택하세요.',
|
||
observedHealth: "관측된 상태",
|
||
reachableMembers: "도달 가능한 멤버",
|
||
keyCount: "키 수",
|
||
backendSize: "백엔드 크기",
|
||
fragmentation: "단편화 추정",
|
||
cluster: "클러스터",
|
||
revision: "리비전",
|
||
leader: "리더",
|
||
noAlarms: "관측된 활성 알람이 없습니다",
|
||
prometheusMetrics: "Prometheus 런타임 메트릭",
|
||
prometheusDescription: "etcd /metrics에서 수집한 안정적인 메트릭입니다. 비율은 인접한 두 샘플에서 계산됩니다.",
|
||
collectedAt: "수집 시각",
|
||
requests: "gRPC 요청 비율",
|
||
requestFailureRate: "요청 실패 비율",
|
||
proposals: "Raft 제안",
|
||
proposalLag: "커밋-적용 간격",
|
||
pending: "대기 중",
|
||
diskLatency: "디스크 지속 대기 시간",
|
||
walFsync: "WAL fsync 평균",
|
||
backendCommit: "백엔드 커밋 평균",
|
||
networkTraffic: "클라이언트 네트워크 트래픽",
|
||
peerTraffic: "피어 트래픽",
|
||
processResources: "프로세스 리소스",
|
||
runtime: "Go 런타임",
|
||
goroutines: "고루틴",
|
||
leaderChanges: "리더 변경 총계",
|
||
failedProposals: "실패한 제안 총계",
|
||
failedProposalRate: "실패 비율",
|
||
rateNeedsRefresh: "실시간 비율을 계산하려면 다시 새로고침하세요",
|
||
storageQuota: "백엔드 할당량 사용",
|
||
uptime: "프로세스 가동 시간",
|
||
consensusReliability: "합의 및 신뢰성",
|
||
leadership: "리더십",
|
||
knownPeers: "알려진 피어",
|
||
proposalState: "제안 상태",
|
||
raftFailures: "Raft 실패",
|
||
revisionState: "MVCC 리비전",
|
||
compactRevision: "컴팩트 리비전",
|
||
requestLoad: "요청 부하",
|
||
grpcMethod: "gRPC 메서드",
|
||
total: "전체",
|
||
rate: "비율",
|
||
failures: "실패",
|
||
avgLatency: "평균 대기 시간",
|
||
storageDisk: "저장 및 디스크",
|
||
databaseState: "데이터베이스 상태",
|
||
inUse: "사용 중",
|
||
openReadTransactions: "열린 읽기 트랜잭션",
|
||
backgroundTasks: "백그라운드 작업",
|
||
watchState: "감시 상태",
|
||
watchers: "감시자",
|
||
watchStreams: "감시 스트림",
|
||
events: "이벤트 비율",
|
||
slowPending: "느림 / 대기",
|
||
leaseState: "리스 수명 주기",
|
||
granted: "부여 비율",
|
||
renewed: "갱신 비율",
|
||
revokedExpired: "취소 / 만료",
|
||
averageTtl: "평균 TTL",
|
||
runtimeResources: "런타임 리소스",
|
||
memory: "메모리",
|
||
processNetworkGc: "프로세스 네트워크 및 GC",
|
||
metricsUnavailable: "Prometheus 메트릭을 사용할 수 없습니다",
|
||
metricsUnavailableHint: "클러스터 상태는 계속 사용할 수 있습니다. DBX가 현재 etcd 엔드포인트에서 직접 /metrics를 요청합니다. 결과 URL이 DBX 애플리케이션에서 도달 가능한지 확인하세요.",
|
||
endpointMember: "엔드포인트 / 멤버",
|
||
role: "역할",
|
||
version: "버전",
|
||
raftTermApplied: "Raft 텀 / 적용",
|
||
dbSizeInUse: "DB 크기 / 사용 중",
|
||
latency: "대기 시간",
|
||
status: "상태",
|
||
learner: "학습자",
|
||
follower: "팔로워",
|
||
reachable: "도달 가능",
|
||
unreachable: "도달 불가",
|
||
loading: "클러스터 관측을 불러오는 중…",
|
||
health: {
|
||
unknown: "알 수 없음",
|
||
critical: "심각",
|
||
warning: "경고",
|
||
healthy: "정상",
|
||
},
|
||
},
|
||
adminPermissionRequired: "이 etcd 페이지는 root 역할에만 공개됩니다.",
|
||
targetKeyWriteDenied: "대상 연결에는 이 Key에 쓸 권한이 없습니다.",
|
||
selectedKeysWriteDenied: "대상 연결에는 선택한 Key에 쓸 권한이 없어 변경 사항이 적용되지 않았습니다.",
|
||
},
|
||
consul,
|
||
sqlServerTrace,
|
||
zookeeper: {
|
||
prefixPlaceholder: "경로 접두사, 예: /app/",
|
||
newKey: "새 Znode",
|
||
loadingKeys: "Znode를 불러오는 중...",
|
||
empty: "Znode가 없습니다",
|
||
loadMore: "더 불러오기",
|
||
selectKey: "값을 보려면 Znode를 선택하세요",
|
||
loadingValue: "값을 불러오는 중...",
|
||
notFound: "Znode를 찾을 수 없습니다",
|
||
edit: "편집",
|
||
editKey: "Znode 편집",
|
||
delete: "삭제",
|
||
deleteTitle: "ZooKeeper Znode 삭제",
|
||
keyPlaceholder: "/path/to/znode",
|
||
keyRequired: "Znode 경로는 필수입니다",
|
||
rootReadonly: "루트 Znode는 수정할 수 없습니다. 하위 Znode 경로를 입력하세요.",
|
||
saved: "Znode를 저장했습니다",
|
||
deleted: "Znode를 삭제했습니다",
|
||
base64Readonly: "Base64 값은 이 버전에서 읽기 전용입니다.",
|
||
utf8PreviewLossy: "잘못된 UTF-8 바이트는 대체 문자(�)로 표시됩니다. 원본 Base64 값은 변경되지 않습니다.",
|
||
utf8PreviewUnavailable: "Base64 값이 잘못되어 UTF-8 미리 보기를 생성할 수 없습니다. 원본 값을 표시합니다.",
|
||
createMode: "생성 모드",
|
||
createModePersistent: "영구",
|
||
createModeEphemeral: "임시",
|
||
createModePersistentSequential: "영구 순차",
|
||
createModeEphemeralSequential: "임시 순차",
|
||
add: "추가",
|
||
value: "값",
|
||
metadata: "노드 정보",
|
||
prettyJson: "보기 좋게",
|
||
invalidJson: "잘못된 JSON",
|
||
summaryRevision: "수정",
|
||
summaryVersion: "버전",
|
||
summaryLease: "리스",
|
||
summarySize: "크기",
|
||
},
|
||
redis: {
|
||
selectKey: "값을 보려면 키를 선택하세요",
|
||
noKeys: "키가 없습니다",
|
||
noKeysInScanHint: "현재 스캔 범위에 키가 없습니다",
|
||
pattern: "패턴 (예: user:*)",
|
||
fuzzyPattern: "키에 포함된...",
|
||
keyTemplateSuggestions: "키 템플릿",
|
||
fuzzyMatch: "퍼지",
|
||
fuzzyMatchTitle: "퍼지 일치: 일반 텍스트 포함으로 키 검색",
|
||
valueSearchPlaceholder: "값에 포함된...",
|
||
allSearchPlaceholder: "키 또는 값에 포함된...",
|
||
searchByKey: "키",
|
||
searchByValue: "값",
|
||
searchByAll: "전체",
|
||
searchFields: "필드와 값 검색",
|
||
searchMembers: "멤버 검색",
|
||
searchItems: "항목 검색",
|
||
keys: "키 {count}개",
|
||
loadedKeys: "{total}개 중 {loaded}개 키 로드됨",
|
||
loadingKeys: "키를 불러오는 중...",
|
||
searchingValues: "값을 검색하는 중...",
|
||
searchingAll: "키와 값을 검색하는 중...",
|
||
loadMoreKeys: "키 더 불러오기",
|
||
fetchAllKeys: "모두 가져오기",
|
||
stopFetchAll: "중지",
|
||
fetchAllProgress: "{total}개 중 {loaded}개 키 로드됨",
|
||
fetchAllProgressUnknown: "키 {loaded}개 로드됨",
|
||
items: "{count}개 항목",
|
||
fields: "{count}개 필드",
|
||
members: "{count}개 멤버",
|
||
loadedItems: "{total}개 중 {loaded}개 항목 로드됨",
|
||
loadedFields: "{total}개 중 {loaded}개 필드 로드됨",
|
||
loadedMembers: "{total}개 중 {loaded}개 멤버 로드됨",
|
||
entries: "{count}개 항목",
|
||
streamData: "스트림 데이터",
|
||
consumerGroups: "컨슈머 그룹",
|
||
group: "그룹",
|
||
consumers: "컨슈머",
|
||
pending: "대기 중",
|
||
lastDeliveredId: "마지막 전달 ID",
|
||
lastDelivered: "마지막 전달",
|
||
entriesRead: "읽은 항목",
|
||
lag: "지연",
|
||
noConsumerGroups: "컨슈머 그룹이 없습니다",
|
||
streamGroupsLoadFailed: "컨슈머 그룹을 불러오는 데 실패했습니다",
|
||
backToGroups: "그룹으로 돌아가기",
|
||
streamConsumers: "컨슈머",
|
||
streamConsumersLoadFailed: "컨슈머를 불러오는 데 실패했습니다",
|
||
noStreamConsumers: "컨슈머가 없습니다",
|
||
openConsumerDetails: "컨슈머 상세 열기",
|
||
consumer: "컨슈머",
|
||
idle: "유휴",
|
||
inactive: "비활성",
|
||
pendingEntries: "대기 항목",
|
||
pendingEntriesLoadFailed: "대기 항목을 불러오는 데 실패했습니다",
|
||
noPendingEntries: "대기 항목이 없습니다",
|
||
entryId: "항목 ID",
|
||
deliveries: "전달",
|
||
loadMoreEntries: "항목 더 불러오기",
|
||
loadMorePending: "대기 항목 더 불러오기",
|
||
noExpiry: "만료 없음",
|
||
noExpiryOnly: "만료 없음만",
|
||
noExpiryOnlyTitle: "로드된 결과에서 만료 없음(TTL = -1) 키만 표시",
|
||
noExpiryKeysEmpty: "로드된 결과에 만료 없음 키가 없습니다",
|
||
ttlCountdownTitle: "로드 시점 TTL 기준 로컬 카운트다운",
|
||
expired: "만료됨",
|
||
expiry: "만료",
|
||
expiryNone: "만료 없음",
|
||
expiryTtl: "TTL (초)",
|
||
expiryAt: "만료 시간 (로컬)",
|
||
expiryTtlInvalid: "초 단위의 양의 정수 TTL을 입력하세요",
|
||
expiryDateRequired: "올바른 만료 시간을 선택하세요",
|
||
expiryDatePast: "만료 시간은 미래여야 합니다",
|
||
keyExpiredBeforeDisplay: "표시하기 전에 키가 만료되었습니다.",
|
||
autoRefresh: "자동 새로고침 카운트다운",
|
||
ttlDay: "{count}일",
|
||
ttlHour: "{count}시간",
|
||
ttlMinute: "{count}분",
|
||
ttlSecond: "{count}초",
|
||
columnType: "타입",
|
||
columnKey: "키",
|
||
columnValue: "값",
|
||
columnSize: "크기",
|
||
columnTTL: "TTL",
|
||
binaryStringReadonlyHint: "바이너리 문자열 값은 읽기 전용 모드에서 이스케이프된 텍스트로 표시되며, 원시 바이트 편집은 지원되지 않습니다.",
|
||
largeStringPreviewHint: "값이 너무 커서 전체 {total} 중 앞부분 {loaded}만 불러왔습니다. 미리 보기는 읽기 전용입니다.",
|
||
largeStringPreviewHintUnknown: "값이 너무 커서 앞부분 {loaded}만 불러왔습니다. 미리 보기는 읽기 전용입니다.",
|
||
largeStringPreviewActionUnavailable: "큰 값 미리 보기에서는 복사, 디코딩 또는 INSERT 문 생성을 사용할 수 없습니다",
|
||
selectedKeys: "선택한 키",
|
||
selectAllLoaded: "전체 선택",
|
||
selectAllLoadedTitle: "모든 키 선택 (Ctrl/Cmd+A)",
|
||
deselectAll: "지우기",
|
||
selectLoadedGroupKeys: "로드된 {count}개 일치 키 선택",
|
||
loadedMatchingKeys: "로드된 일치 키 {count}개",
|
||
loadedGroupKeysPartial: "지금까지 로드된 {count}개 키 — 이 폴더에 더 많은 키가 있을 수 있습니다",
|
||
fuzzyTreeLimit: "{count}개의 퍼지 일치가 브라우저 응답성을 유지하기 위해 평면 목록으로 표시됩니다. 계층 구조를 보려면 검색을 좁히세요.",
|
||
deleteGroup: "그룹 삭제",
|
||
deleteKey: "키 삭제",
|
||
deleteGroupDetails: "{target}\n키 {count}개",
|
||
deleteLoadedSearchKeysDetails: "{target}\n로드된 일치 키 {count}개",
|
||
batchExpiry: "만료 시간 설정",
|
||
batchExpiryTitle: "만료 시간 일괄 설정",
|
||
batchExpirySelected: "키 {count}개 선택됨",
|
||
batchExpiryApply: "적용",
|
||
batchExpirySuccess: "키 {count}개에 만료 시간을 설정했습니다",
|
||
batchExpiryPartial: "성공 {success}개, 실패 {failed}개",
|
||
flushDb: "현재 DB 비우기",
|
||
flushDbMessage: "현재 Redis 데이터베이스의 모든 키를 삭제하며 되돌릴 수 없습니다. 계속하시겠습니까?",
|
||
flushDbDetails: "대상: Redis db{db}\n범위: 현재 DB의 모든 키",
|
||
flushDbConfirm: "DB 비우기",
|
||
flushDbSuccess: "Redis db{db} 비움",
|
||
keyDetail: "키 상세",
|
||
commandLine: "명령줄",
|
||
selectKeyForDetail: "상세를 보려면 키를 선택하세요",
|
||
commandWelcome: "Redis 명령 콘솔에 오신 것을 환영합니다",
|
||
commandPlaceholder: "Redis 명령, 예: GET user:1",
|
||
commandPrefix: "CMD",
|
||
commandHint: "Redis 명령을 입력하세요, 예: SMEMBERS feature:flags",
|
||
executeCommand: "명령 실행",
|
||
commandEmpty: "Redis 명령을 입력하세요",
|
||
commandEmptyResult: "결과를 보려면 Redis 명령을 실행하세요",
|
||
commandBlocked: "이 Redis 명령은 안전을 위해 차단되었습니다",
|
||
createKey: "키 만들기",
|
||
createKeyName: "키",
|
||
createKeyNamePlaceholder: "user:1",
|
||
createKeyType: "타입",
|
||
createKeyTypeHelp: {
|
||
string: "최대 512MB의 단일 바이너리 안전 값. 캐시 값, 카운터, 플래그 및 단순 직렬화 데이터에 가장 적합합니다.",
|
||
hash: "평면 필드-값 맵. 개별 필드에 효율적이지만 대규모 해시를 전체 읽는 것은 O(N)입니다.",
|
||
list: "순서가 있는 시퀀스. 머리와 꼬리 작업이 효율적이며 중간의 무작위 접근은 리스트 길이에 비례합니다.",
|
||
set: "고유 멤버의 순서 없는 모음. 단일 멤버 작업은 O(1)이며 대규모 세트의 열거나 결합은 선형입니다.",
|
||
zset: "부동소수점 점수로 정렬된 고유 멤버. 쓰기는 O(log N)이며 점수가 같은 멤버는 사전순으로 정렬됩니다.",
|
||
stream: "추가 전용 이벤트 로그. 컨슈머 그룹은 XACK과 대기 항목 처리가 필요하며, 보존과 메모리를 제어하려면 스트림을 다듬으세요.",
|
||
json: "경로로 주소 지정 가능한 JSON 문서. RedisJSON/Redis Stack JSON.* 지원이 필요하며 일반적으로 String이나 Hash보다 오버헤드가 큽니다.",
|
||
},
|
||
createValue: "값",
|
||
createMember: "멤버",
|
||
createField: "필드",
|
||
createFieldPlaceholder: "이름",
|
||
createScore: "점수",
|
||
createKeyTtl: "TTL (초)",
|
||
createKeyTtlPlaceholder: "양의 정수 초",
|
||
createKeyAddEntry: "항목 추가",
|
||
createKeyEntryId: "항목 ID",
|
||
createKeyRawMode: "원시 입력",
|
||
createKeyEntries: "항목",
|
||
createKeyPartialWrite: "일부 항목이 작성되었습니다. 오류를 수정하고 나머지 항목을 작성하려면 다시 만드세요.",
|
||
createValuePlaceholder: "값",
|
||
createKeySubmit: "만들기",
|
||
createKeyNameRequired: "키 이름을 입력하세요",
|
||
renameKey: "키 이름 변경",
|
||
renameKeyName: "키 이름",
|
||
renameKeyNameRequired: "키 이름을 입력하세요",
|
||
renameKeySuccess: '"{oldName}"을(를) "{newName}"(으)로 변경했습니다',
|
||
createFieldRequired: "해시 필드를 입력하세요",
|
||
createScoreInvalid: "올바른 점수를 입력하세요",
|
||
jsonModuleNotAvailable: "이 Redis 서버에 ReJSON 모듈이 로드되지 않았습니다",
|
||
fieldRequired: "필드 이름을 입력하세요",
|
||
valueRequired: "값을 입력하세요",
|
||
memberRequired: "멤버를 입력하세요",
|
||
updateAppliedRefreshFailed: "변경 사항은 저장되었지만 값을 새로 고치지 못했습니다: {message}",
|
||
zsetAclCompatibilityWarning: "ACL 호환 모드로 저장했습니다. 동시에 변경된 점수는 확인할 수 없습니다.",
|
||
ttlInvalid: "초 단위의 올바른 TTL을 입력하세요 (만료 없음은 -1)",
|
||
member: "멤버",
|
||
memberDetail: "멤버 상세",
|
||
viewMember: "전체 값 보기",
|
||
copyMember: "멤버 복사",
|
||
copyField: "필드 복사",
|
||
copyFieldValue: "필드 및 값 복사",
|
||
copyOptions: "복사 옵션",
|
||
copyKeyName: "키 이름 복사",
|
||
copyKeyPath: "키 경로 복사",
|
||
deleteGroupKeys: "키 일괄 삭제",
|
||
copied: "복사했습니다",
|
||
copyInsertStatement: "INSERT 구문 복사",
|
||
copyInsertStatementBinary: "바이너리 데이터에 대한 INSERT 구문을 생성할 수 없습니다",
|
||
editMember: "편집",
|
||
jsonView: "JSON 보기",
|
||
jsonViewRaw: "원본",
|
||
jsonViewDecoded: "디코딩",
|
||
rawContent: "원시 내용",
|
||
wordWrap: "자동 줄바꿈",
|
||
codecNone: "없음",
|
||
codecRowLabel: "디코딩",
|
||
viewRowLabel: "보기",
|
||
codecBase64: "Base64",
|
||
codecMismatch: "선택한 디코딩 방식으로 복원할 수 없어 원본 내용을 표시합니다",
|
||
unicodeJsonView: "Unicode JSON",
|
||
decompressedView: "압축 해제 보기",
|
||
decompressedLoading: "압축 해제 중…",
|
||
decompressedFailed: "선택한 형식으로 압축을 해제할 수 없습니다",
|
||
decompressedRetryAsDeflate: "Deflate로 재시도",
|
||
decompressedLimitExceeded: "압축 해제 결과가 50 MiB 제한을 초과합니다",
|
||
gzipBadgeTitle: "Gzip 압축 — 클릭하여 압축 해제 내용 보기",
|
||
formatJson: "서식",
|
||
compressJson: "압축",
|
||
jsonFormatError: "잘못된 JSON 형식",
|
||
clearHistory: "명령 기록 지우기",
|
||
historyCleared: "Redis 명령 기록을 지웠습니다",
|
||
blockedCommand: "{command} 명령은 안전을 위해 차단되었습니다. 허용하려면 도구 모음의 방패 아이콘을 비활성화하세요.",
|
||
pubsub: "Pub/Sub",
|
||
pubsubConnected: "연결됨",
|
||
pubsubConnecting: "연결하는 중...",
|
||
pubsubDisconnected: "연결 끊김",
|
||
pubsubConnect: "연결",
|
||
pubsubDisconnect: "연결 끊기",
|
||
pubsubChannels: "채널",
|
||
pubsubChannelPlaceholder: "채널 이름",
|
||
pubsubSubscribe: "구독",
|
||
pubsubPatterns: "패턴",
|
||
pubsubPatternPlaceholder: "패턴 (예: news:*)",
|
||
pubsubPsubscribe: "PSubscribe",
|
||
pubsubMessages: "메시지",
|
||
pubsubClear: "지우기",
|
||
pubsubEmpty: "아직 메시지가 없습니다. 메시지를 받으려면 채널을 구독하세요.",
|
||
pubsubPublish: "게시",
|
||
pubsubPublishChannel: "채널",
|
||
pubsubPublishMessage: "메시지",
|
||
pubsubSend: "보내기",
|
||
pubsubPublishFailed: "게시 실패: {error}",
|
||
pubsubWsConnectFailed: "WebSocket 연결 실패: {error}",
|
||
slowlog: "슬로우 로그",
|
||
slowlogCount: "개수",
|
||
slowlogQuery: "조회",
|
||
slowlogNode: "노드",
|
||
slowlogSelectNode: "노드를 선택하세요",
|
||
slowlogNodeRequired: "먼저 노드를 선택하세요",
|
||
slowlogEmpty: "슬로우 로그 항목을 가져오려면 조회를 클릭하세요",
|
||
slowlogFetchFailed: "슬로우 로그를 가져오는 데 실패했습니다: {error}",
|
||
slowlogColumnId: "ID",
|
||
slowlogColumnTimestamp: "타임스탬프",
|
||
slowlogColumnDuration: "소요 시간 (μs)",
|
||
slowlogColumnCommand: "명령",
|
||
slowlogColumnClientAddr: "클라이언트",
|
||
slowlogColumnClientName: "클라이언트 이름",
|
||
slowlogTotal: "{count}개 항목",
|
||
slowlogDetailTitle: "슬로우 로그 항목 #{id}",
|
||
dashboard: {
|
||
totalMemory: "전체 메모리",
|
||
usedMemory: "사용 중인 메모리",
|
||
operations: "작업",
|
||
hitRatio: "적중률",
|
||
keyCount: "키 수",
|
||
clients: "클라이언트",
|
||
searchIndicators: "지표 검색...",
|
||
node: "노드",
|
||
off: "꺼짐",
|
||
refresh: "새로고침",
|
||
noMatchingIndicators: "일치하는 지표가 없습니다",
|
||
noDataAvailable: "데이터가 없습니다",
|
||
sections: {
|
||
server: "서버",
|
||
clients: "클라이언트",
|
||
memory: "메모리",
|
||
persistence: "지속성",
|
||
stats: "통계",
|
||
replication: "복제",
|
||
cpu: "CPU",
|
||
modules: "모듈",
|
||
commandstats: "명령 통계",
|
||
errorstats: "오류 통계",
|
||
latencystats: "대기 시간 통계",
|
||
cluster: "클러스터",
|
||
keyspace: "키스페이스",
|
||
},
|
||
},
|
||
monitorStop: "모니터링 중지",
|
||
monitorListening: "MONITOR 모니터링 중 · 최근 1000개 보관 · 너무 긴 레코드는 잘림 표시",
|
||
keySearchHistory: "검색 기록",
|
||
keySearchHistoryForget: "기록에서 제거",
|
||
keySearchHistoryEmpty: "검색 기록이 없습니다",
|
||
},
|
||
mongo: {
|
||
documents: "문서 {count}개",
|
||
addField: "필드 추가",
|
||
deleteField: "필드 삭제",
|
||
field: "필드",
|
||
value: "값",
|
||
fieldPlaceholder: "필드 이름",
|
||
emptyCollection: "빈 컬렉션",
|
||
selectDocument: "문서를 선택하세요",
|
||
readonlyId: "_id는 읽기 전용입니다",
|
||
invalidJsonValue: "이 셀은 올바른 JSON 값이 아닙니다",
|
||
invalidJson: "잘못된 JSON",
|
||
documentMustBeObject: "문서 JSON은 객체여야 합니다",
|
||
unsupportedJsonNumber: "JSON에 MongoDB int64 범위를 벗어나는 숫자가 포함되어 있습니다",
|
||
duplicateJsonKey: "중복된 JSON 키: {field}",
|
||
duplicateField: "중복된 필드 이름: {field}",
|
||
edit: "편집",
|
||
editModeFields: "필드",
|
||
editModeJson: "JSON",
|
||
jsonReplaceHint: "JSON 저장은 전체 문서를 대체합니다. _id를 변경하면 새 문서가 생성되고 이전 문서는 삭제됩니다.",
|
||
jsonIdRequired: "문서 식별자를 변경하려면 올바른 _id가 필요합니다.",
|
||
documentView: "문서 보기",
|
||
tableView: "테이블 보기",
|
||
filterPlaceholder: "필터...",
|
||
sortPlaceholder: "정렬...",
|
||
indexExpireAfterSeconds: "만료 시간(초)",
|
||
indexExpireAfterSecondsPlaceholder: "만료 안 함",
|
||
indexExpireAfterSecondsHint: "단일 필드 인덱스만 해당. 인덱스 날짜 필드가 이 시간을 초과하면 MongoDB가 해당 문서를 삭제합니다.",
|
||
indexPartialFilter: "부분 필터",
|
||
indexLegacyOptions: "호환 옵션",
|
||
indexLegacyOptionsHint: "이전 서버 버전에만 의미: MongoDB 4.2부터 background가 무시되고, 4.4에서 geoHaystack 인덱스가 제거된 후 bucket size는 더 이상 적용되지 않습니다.",
|
||
indexBackground: "백그라운드",
|
||
indexBucketSize: "버킷 크기",
|
||
indexSparse: "희소",
|
||
indexHidden: "숨김",
|
||
indexNoExpiry: "만료 안 함",
|
||
indexOtherOptions: "기타 옵션",
|
||
indexPropertiesUnavailable: "MongoDB Legacy 드라이버는 희소, 만료, 백그라운드 또는 버킷 크기를 보고할 수 없습니다. 네이티브 드라이버로 연결하여 확인하세요.",
|
||
import: {
|
||
title: "데이터 가져오기",
|
||
target: "대상 컬렉션",
|
||
readonly: "이 연결은 읽기 전용입니다. 가져오기 전에 쓰기를 잠금 해제하세요.",
|
||
chooseFile: "파일 선택",
|
||
fileFilter: "MongoDB 데이터",
|
||
noFile: "선택된 파일 없음",
|
||
back: "뒤로",
|
||
format: "형식",
|
||
encoding: "인코딩",
|
||
delimiter: "구분 기호",
|
||
typeMode: "유형 모드",
|
||
typeString: "모두 문자열",
|
||
typeAuto: "자동 감지",
|
||
typeExtendedJson: "Extended JSON",
|
||
columnType: "{name} 유형",
|
||
inferredType: {
|
||
string: "문자열",
|
||
boolean: "불리언",
|
||
integer: "정수",
|
||
decimal: "소수",
|
||
date: "날짜",
|
||
objectId: "ObjectId",
|
||
object: "객체",
|
||
array: "배열",
|
||
mixed: "혼합",
|
||
},
|
||
hasHeader: "첫 행을 헤더로 사용",
|
||
trim: "값 앞뒤 공백 제거",
|
||
emptyAsNull: "빈 셀을 null로 기록",
|
||
recognizeObjectIdHex: "24자 16진수를 ObjectId로 인식",
|
||
skipErrorRows: "오류 행 건너뛰기",
|
||
previewing: "미리보기 새로 고치는 중…",
|
||
estimatedRows: "약 {count}개 문서",
|
||
continue: "계속",
|
||
confirmAppend: "문서는 추가됩니다. 기존 문서는 비우거나 upsert하지 않습니다.",
|
||
batchSize: "배치 크기",
|
||
duplicateIdPolicy: "중복 _id는 가져오기를 중지합니다. 이미 커밋된 배치는 롤백되지 않습니다.",
|
||
start: "가져오기",
|
||
success: "{count}개 문서를 가져왔습니다",
|
||
stillRunning: "가져오기가 계속 실행 중입니다. 이후 배치를 멈추려면 취소를 사용하세요.",
|
||
legacyInsertUnsupported: "이 MongoDB Legacy 드라이버는 문서 일괄 삽입을 지원하지 않습니다. MongoDB Legacy 드라이버를 업그레이드하거나 다시 설치하세요.",
|
||
legacyCursorInvalid: "MongoDB Legacy 내보내기 커서를 더 이상 사용할 수 없습니다. 내보내기를 다시 시도하세요.",
|
||
legacyExportUnsupported: "이 MongoDB Legacy 드라이버는 내보내기 시 BSON 타입 유지를 지원하지 않습니다. MongoDB Legacy 드라이버를 업그레이드하거나 다시 설치하세요.",
|
||
legacyExportStalled: "MongoDB Legacy 드라이버가 동일한 내보내기 페이지를 두 번 반환했습니다. 드라이버를 업그레이드하거나 다시 설치한 후 다시 시도하세요.",
|
||
legacyExportMissingId: "MongoDB Legacy 드라이버가 _id 없는 문서를 반환해 안전하게 페이지 매김할 수 없습니다.",
|
||
rowsRead: "읽은 행",
|
||
rowsInserted: "삽입된 행",
|
||
rowsFailed: "실패한 행",
|
||
batchesCommitted: "커밋된 배치",
|
||
phase: {
|
||
preparing: "준비 중",
|
||
parsing: "구문 분석 중",
|
||
writing: "쓰는 중",
|
||
done: "완료",
|
||
},
|
||
},
|
||
insert: {
|
||
partialFailure: "MongoDB Legacy 드라이버가 {total}개 문서 중 {failed}개를 거부했습니다: {message}",
|
||
},
|
||
},
|
||
meilisearch: {
|
||
...meilisearchManagementKo,
|
||
documents: "문서",
|
||
settings: "설정",
|
||
search: "검색",
|
||
keywordPlaceholder: "문서 검색...",
|
||
filter: "필터",
|
||
filterPlaceholder: 'status = "published"',
|
||
sort: "정렬",
|
||
sortPlaceholder: "필드:asc",
|
||
sortHint: "여러 정렬식은 반각 쉼표(,)로 구분합니다",
|
||
sortNoAttributes: "이 인덱스에 설정된 정렬 가능 속성이 없습니다",
|
||
sortAsc: "오름차순",
|
||
sortDesc: "내림차순",
|
||
limit: "제한",
|
||
offset: "오프셋",
|
||
resultSummary: "약 {count}개 결과 · {time}ms",
|
||
viewJson: "JSON",
|
||
viewTable: "표",
|
||
viewGrid: "그리드",
|
||
empty: "문서를 찾을 수 없습니다",
|
||
editDocument: "문서 편집",
|
||
deleteDocument: "문서 삭제",
|
||
deleteDocumentMessage: "이 문서를 삭제할까요? 이 작업은 되돌릴 수 없습니다.",
|
||
documentDeleted: "문서가 삭제되었습니다",
|
||
documentSaved: "문서가 저장되었습니다",
|
||
settingsSaved: "설정이 저장되었습니다",
|
||
invalidJson: "잘못된 JSON",
|
||
settingsJson: "설정 JSON",
|
||
dangerZone: "위험 구역",
|
||
clearDocuments: "모든 문서 비우기",
|
||
clearDocumentsConfirmMessage: "인덱스의 모든 문서가 제거됩니다. 이 작업은 되돌릴 수 없습니다.",
|
||
documentsCleared: "모든 문서가 삭제되었습니다",
|
||
deleteIndex: "인덱스 삭제",
|
||
deleteIndexConfirmMessage: "인덱스와 모든 문서가 영구적으로 삭제됩니다.",
|
||
indexDeleted: "인덱스가 삭제되었습니다",
|
||
isIndexing: "인덱싱 중",
|
||
uid: "UID",
|
||
updatedAt: "업데이트됨",
|
||
primaryKey: "기본 키",
|
||
documentCountLabel: "문서 수",
|
||
databaseSize: "데이터베이스 크기",
|
||
copyDocument: "JSON 복사",
|
||
copied: "복사됨",
|
||
autoRefresh: "자동 새로고침",
|
||
hybrid: "하이브리드 검색",
|
||
hybridEmbedder: "임베더",
|
||
hybridSemanticRatio: "의미 비율",
|
||
hybridNoEmbedders: "인덱스 설정에 구성된 임베더가 없습니다. 직접 입력하세요.",
|
||
showRankingScore: "랭킹 점수",
|
||
rankingScoreThreshold: "점수 임계값",
|
||
results: "검색 결과",
|
||
exportResults: "결과보내기",
|
||
exportSearchUnsupported: "Meilisearch는 텍스트, 하이브리드 또는 점수 임계값 검색의 페이지 탐색을 제한합니다. 필터링된 모든 문서를 내보내려면 해당 옵션을 지우세요.",
|
||
},
|
||
dynamodb: {
|
||
tableMetadataUnavailable: "DynamoDB 테이블 메타데이터가 로드되지 않았습니다. 새로 고친 후 다시 시도하세요.",
|
||
keyRequired: "DynamoDB 항목에는 키 속성 {key}이(가) 필요합니다",
|
||
baseTable: "기본 테이블",
|
||
filter: "필터",
|
||
sortKey: "정렬 키",
|
||
items: "항목 {count}개",
|
||
index: "DynamoDB 인덱스",
|
||
keySummary: "파티션 키: {partitionKey}; 정렬 키: {sortKey}",
|
||
none: "없음",
|
||
sortKeyOnly: "DynamoDB Query는 현재 인덱스의 정렬 키 {key}로만 정렬할 수 있습니다",
|
||
pageCursorUnavailable: "DynamoDB 페이지 커서를 사용할 수 없습니다. 첫 페이지부터 다시 불러오세요.",
|
||
repeatedCursor: "DynamoDB가 중복 페이지 커서를 반환하여 내보내기를 중지했습니다.",
|
||
partialProjectionReadOnly: "이 {projection} 인덱스에는 전체 항목이 포함되지 않으므로 투영되지 않은 속성이 덮어쓰이지 않도록 편집을 비활성화했습니다.",
|
||
exportLimitReached: "메모리와 읽기 사용량을 제한하기 위해 DynamoDB 내보내기가 {count}개 항목에서 중지되었습니다. 다른 범위를 사용하려면 내보내기 행 제한을 설정하세요.",
|
||
documentDetails: "DynamoDB 테이블: {table}\n항목 키: {id}",
|
||
},
|
||
vector: {
|
||
collectionFallback: "컬렉션",
|
||
productCollection: "{product} 컬렉션",
|
||
browse: "탐색",
|
||
search: "검색",
|
||
upsert: "Upsert",
|
||
delete: "삭제",
|
||
reset: "재설정",
|
||
refresh: "새로고침",
|
||
run: "실행",
|
||
apply: "적용",
|
||
requestEditor: "벡터 요청 편집기",
|
||
operationSuccess: "작업이 완료되었습니다. 컬렉션 미리보기를 새로고침했습니다.",
|
||
vectorLabel: "벡터",
|
||
vectorDimensionRequired: "컬렉션 차원을 아직 사용할 수 없습니다. 컬렉션 차원에 맞는 벡터를 입력하세요.",
|
||
},
|
||
hbase: {
|
||
prefix: "접두사",
|
||
exact: "정확히 일치",
|
||
rowKeyPrefix: "로우 키 접두사",
|
||
rowKey: "로우 키",
|
||
rows: "행",
|
||
schema: "스키마",
|
||
writeRow: "행 쓰기",
|
||
loadedRows: "{count}행 로드됨",
|
||
resultTruncated: "더 많은 행이 있습니다",
|
||
tableSchema: "스키마: {table}",
|
||
rowSaved: "HBase 행을 저장했습니다",
|
||
cellsObjectRequired: "cells는 JSON 객체여야 합니다",
|
||
cellRequired: "최소 한 개의 셀이 필요합니다",
|
||
noColumnFamilies: "이 HBase 테이블에는 컬럼 패밀리가 없습니다",
|
||
invalidJsonValue: "{label}의 값이 잘못되었습니다. 텍스트, 원시 값 또는 base64:...을 사용하세요",
|
||
createTable: "테이블 만들기",
|
||
create: "만들기",
|
||
tableCreated: "HBase 테이블 {table}을(를) 만들었습니다",
|
||
tableDeleted: "HBase 테이블 {table}을(를) 삭제했습니다",
|
||
createTableIn: "{namespace}에 테이블 만들기",
|
||
tableName: "테이블 이름",
|
||
columnFamiliesPlaceholder: "컬럼 패밀리, 쉼표로 구분",
|
||
deleteTable: "테이블 삭제",
|
||
deleteTableConfirm: "HBase 테이블 {table}을(를) 삭제하시겠습니까? 모든 행이 영구적으로 제거됩니다.",
|
||
},
|
||
history: {
|
||
title: "기록",
|
||
search: "기록 검색...",
|
||
conversationSearch: "대화 검색...",
|
||
empty: "아직 기록이 없습니다",
|
||
emptyConversationSearch: "검색과 일치하는 대화가 없습니다",
|
||
emptyFilteredRecent: "최근 200개의 실행 기록에서 일치하는 항목이 없습니다",
|
||
failed: "실패",
|
||
success: "성공",
|
||
restore: "편집기로 복원",
|
||
copy: "SQL 복사",
|
||
delete: "삭제",
|
||
clear: "기록 비우기",
|
||
viewDetails: "상세 보기",
|
||
analyzeWithAi: "AI로 분석",
|
||
aiAnalyzeNoConnection: "이 기록 항목의 연결이 더 이상 존재하지 않아 분석할 수 없습니다.",
|
||
aiAnalysisTab: "기록 분석",
|
||
rollback: "롤백",
|
||
rollbackSql: "롤백 SQL",
|
||
rollbackAvailable: "가능",
|
||
rollbackUnavailable: "롤백 SQL 없음",
|
||
rollbackConfirm: "이 기록 항목에 대해 생성된 롤백 SQL을 실행하시겠습니까?",
|
||
rollbackSuccess: "롤백을 실행했습니다",
|
||
rollbackFailed: "롤백 실패: {message}",
|
||
confirmDelete: "이 기록 항목을 삭제하시겠습니까?",
|
||
confirmClear: "모든 기록을 비우시겠습니까?",
|
||
emptyFiltered: "현재 필터와 일치하는 기록이 없습니다",
|
||
loadMore: "더 불러오기",
|
||
scope: {
|
||
title: "연결 및 데이터베이스",
|
||
search: "연결 또는 데이터베이스 검색...",
|
||
reset: "재설정",
|
||
allConnections: "모든 연결",
|
||
current: "현재",
|
||
connections: "연결",
|
||
databases: "데이터베이스",
|
||
connectionCount: "연결 {count}개",
|
||
databaseCount: "데이터베이스 {count}개",
|
||
unknownConnection: "알 수 없는 연결",
|
||
noOptions: "일치하는 옵션이 없습니다",
|
||
},
|
||
filters: {
|
||
all: "전체",
|
||
query: "쿼리",
|
||
data_change: "데이터 변경",
|
||
schema_change: "스키마 변경",
|
||
failed: "실패",
|
||
},
|
||
dateRange: {
|
||
title: "시간 범위",
|
||
label: "실행 시간:",
|
||
start: "시작 날짜",
|
||
end: "종료 날짜",
|
||
apply: "적용",
|
||
clear: "지우기",
|
||
invalid: "시작 날짜는 종료 날짜보다 늦을 수 없습니다",
|
||
unboundedStart: "시작",
|
||
unboundedEnd: "종료",
|
||
},
|
||
kinds: {
|
||
query: "쿼리",
|
||
data_change: "데이터 변경",
|
||
schema_change: "스키마 변경",
|
||
import: "가져오기",
|
||
transfer: "이전",
|
||
redis_command: "Redis 명령",
|
||
},
|
||
kindShort: {
|
||
query: "SQL",
|
||
data_change: "데이터",
|
||
schema_change: "DDL",
|
||
import: "가져오기",
|
||
transfer: "이동",
|
||
redis_command: "Redis",
|
||
},
|
||
detail: {
|
||
kind: "유형",
|
||
operation: "작업",
|
||
connection: "연결",
|
||
database: "데이터베이스",
|
||
target: "대상",
|
||
time: "시간",
|
||
duration: "소요 시간",
|
||
affectedRows: "영향 받은 행",
|
||
rollback: "롤백",
|
||
status: "상태",
|
||
error: "오류",
|
||
},
|
||
},
|
||
dangerDialog: {
|
||
title: "위험한 작업",
|
||
message: "이 SQL 구문은 데이터를 되돌릴 수 없게 수정하거나 삭제할 수 있습니다. 정말 실행하시겠습니까?",
|
||
redisCommandMessage: "이 Redis 명령은 데이터를 수정할 수 있으며 자동으로 되돌릴 수 없습니다. 계속하시겠습니까?",
|
||
suppressFuturePrompts: "위험한 SQL에 대해 다시 묻지 않기",
|
||
wrapLines: "자동 줄바꿈 전환",
|
||
copyFullText: "전체 텍스트 복사",
|
||
previewTruncated: "미리보기가 잘렸습니다: {characters}자, {lines}줄이 생략되었습니다. 복사에는 전체 텍스트가 포함됩니다.",
|
||
deleteMessage: "이 삭제 작업은 되돌릴 수 없습니다. 계속하시겠습니까?",
|
||
deleteConfirm: "삭제 확인",
|
||
deleteRowMessage: "이 행은 삭제로 표시되며 저장 후 데이터베이스에서 제거됩니다. 계속하시겠습니까?",
|
||
deleteRowsMessage: "이 {count}개 행은 삭제로 표시되며 저장 후 데이터베이스에서 제거됩니다. 계속하시겠습니까?",
|
||
deleteRowDetails: "테이블: {table}",
|
||
deleteRowDetailsNoTable: "현재 결과 행",
|
||
redisKeyDetails: "Redis 키: {key}",
|
||
redisHashFieldDetails: "Redis 해시: {key}\n필드: {field}",
|
||
redisListItemDetails: "Redis 리스트: {key}\n인덱스: {index}",
|
||
redisSetMemberDetails: "Redis 세트: {key}\n멤버: {member}",
|
||
mongoDocumentDetails: "MongoDB 컬렉션: {collection}\n문서 _id: {id}",
|
||
mongoFieldDetails: "필드: {field}",
|
||
mongoArrayItemDetails: "배열 항목 인덱스: {index}",
|
||
cancel: "취소",
|
||
cancelRunning: "쿼리 취소",
|
||
confirm: "실행",
|
||
},
|
||
production: {
|
||
title: "프로덕션 환경",
|
||
connection: "프로덕션 연결",
|
||
enable: "프로덕션 보호 활성화",
|
||
disabledDescription: "모든 데이터베이스 또는 선택한 데이터베이스를 보호하려면 활성화하세요.",
|
||
scope: "보호 범위",
|
||
allDatabases: "모든 데이터베이스",
|
||
selectedDatabases: "선택한 데이터베이스",
|
||
singleDatabaseScopeHint: "이 데이터베이스 유형은 연결 수준의 프로덕션 보호만 지원합니다.",
|
||
databases: "프로덕션 데이터베이스",
|
||
connectionDescription: "이 연결의 모든 데이터베이스에 프로덕션 보호가 적용됩니다.",
|
||
databaseDescription: "프로덕션 보호가 필요한 데이터베이스를 선택하세요. 첫 번째 선택에는 모든 데이터베이스가 포함됩니다.",
|
||
selectDatabases: "프로덕션 데이터베이스 선택",
|
||
noDatabasesSelected: "선택한 데이터베이스가 없습니다",
|
||
databasesConfiguredCount: "{count}개 선택됨",
|
||
databasesSelectedCount: "{selected}/{total} 선택됨",
|
||
databasePickerTitle: "프로덕션 데이터베이스 선택",
|
||
databasePickerDescription: '"{connection}"에서 프로덕션 보호가 필요한 데이터베이스를 선택하세요.',
|
||
databaseSearchPlaceholder: "데이터베이스 검색...",
|
||
databaseSelectionRequired: "최소 한 개의 데이터베이스를 선택하세요.",
|
||
databaseLoadFailed: "데이터베이스를 불러올 수 없습니다: {message}",
|
||
noDatabasesAvailable: "선택할 수 있는 데이터베이스가 없습니다.",
|
||
namespaceDisabledDescription: "활성화하면 모든 네임스페이스 또는 선택한 네임스페이스를 보호하도록 선택할 수 있습니다.",
|
||
allNamespaces: "모든 네임스페이스",
|
||
selectedNamespaces: "선택한 네임스페이스",
|
||
namespaces: "프로덕션 네임스페이스",
|
||
namespaceConnectionDescription: "이 연결의 모든 네임스페이스에 프로덕션 보호가 활성화됩니다.",
|
||
namespaceDescription: "연결에서 프로덕션 보호가 필요한 네임스페이스를 선택하세요. 첫 번째 선택에는 모든 네임스페이스가 포함됩니다.",
|
||
selectNamespaces: "프로덕션 네임스페이스 선택",
|
||
namespacePickerTitle: "프로덕션 네임스페이스 선택",
|
||
namespacePickerDescription: "「{connection}」에서 프로덕션 보호가 필요한 네임스페이스를 선택하세요.",
|
||
namespaceSearchPlaceholder: "네임스페이스 검색...",
|
||
namespaceSelectionRequired: "최소 한 개의 네임스페이스를 선택하세요.",
|
||
namespaceLoadFailed: "네임스페이스 목록을 불러올 수 없습니다: {message}",
|
||
noNamespacesAvailable: "선택할 수 있는 네임스페이스가 없습니다.",
|
||
retry: "다시 시도",
|
||
confirmTitle: "프로덕션 쓰기 확인",
|
||
confirmMessage: "이 작업은 프로덕션 데이터베이스를 변경하므로 명시적인 확인이 필요합니다.",
|
||
confirmDetails: "연결: {connection}\n데이터베이스: {database}\n출처: {source}",
|
||
confirmAction: "프로덕션에서 실행",
|
||
sourceSqlEditor: "SQL 편집기",
|
||
sourceDataGrid: "데이터 편집기",
|
||
sourceStructure: "구조 편집기",
|
||
sourceSqlFile: "SQL 파일 실행",
|
||
sourceObjectBrowser: "객체 브라우저",
|
||
sourceSchemaDiff: "스키마 비교",
|
||
sourceDataCompare: "데이터 비교",
|
||
sourceExtension: "확장 관리자",
|
||
sourceSidebar: "객체 트리",
|
||
sourceMq: "메시지 큐",
|
||
sourceObjectSource: "객체 소스 편집기",
|
||
sourceDataGenerate: "데이터 생성기",
|
||
sourceQueryHistory: "쿼리 기록 롤백",
|
||
sourceAdmin: "데이터베이스 관리",
|
||
aiReviewRequired: "프로덕션 SQL이 편집기에 추가되었습니다. 확인하려면 검토 후 수동으로 실행하세요.",
|
||
},
|
||
readOnlyUnlock: {
|
||
confirmTitle: "쓰기 잠금 해제",
|
||
confirmMessage: "이 연결은 읽기 전용입니다. 짧은 시간 동안 잠금을 해제하지 않으면 쓰기가 계속 차단됩니다. 저장된 읽기 전용 설정은 꺼지지 않습니다.",
|
||
confirmDetails: "연결: {connection}\n출처: {source}\n선택한 시간 동안 쓰기가 허용된 뒤 자동으로 읽기 전용으로 돌아갑니다.",
|
||
confirmAction: "쓰기 잠금 해제",
|
||
durationLabel: "쓰기 허용 시간",
|
||
durationOneMinute: "1분",
|
||
durationFiveMinutes: "5분",
|
||
remaining: "{time} 남음",
|
||
unlockedBadge: "쓰기 잠금 해제됨",
|
||
lockNow: "지금 다시 잠금",
|
||
unlockAction: "쓰기 잠금 해제…",
|
||
sourceImport: "테이블 가져오기",
|
||
sourceMongoImport: "MongoDB 가져오기",
|
||
sourceTransfer: "데이터 이전",
|
||
sourceSqlFile: "SQL 파일 실행",
|
||
sourceStatus: "읽기 전용 컨트롤",
|
||
sourceDataEditor: "데이터 편집기",
|
||
},
|
||
sqlParameters: {
|
||
title: "SQL 매개변수",
|
||
description: "SQL 템플릿 자리표시자의 값을 입력하세요. DBX가 SQL을 실행하기 전에 대체합니다.",
|
||
name: "매개변수",
|
||
syntax: "문법",
|
||
type: "유형",
|
||
value: "값",
|
||
valuePlaceholder: "값 입력",
|
||
collectionValuePlaceholder: "JSON 배열 또는 쉼표로 구분된 값 입력",
|
||
preview: "SQL 미리보기",
|
||
execute: "실행",
|
||
clearValues: "값 지우기",
|
||
useRawForAll: "모두 원시 SQL로 설정",
|
||
ignore: "무시",
|
||
kind: {
|
||
string: "문자열",
|
||
number: "숫자",
|
||
boolean: "불리언",
|
||
null: "NULL",
|
||
raw: "원본 SQL",
|
||
},
|
||
},
|
||
transfer: {
|
||
title: "데이터 이전",
|
||
content: "전송 내용",
|
||
contentStructureAndData: "구조 및 데이터",
|
||
contentStructureOnly: "구조만",
|
||
contentDataOnly: "데이터만",
|
||
contentStructureOnlyHint: "테이블 및 개체 구조만 생성하고 데이터는 복사하지 않습니다",
|
||
contentDataOnlyHint: "기존 대상 테이블에 데이터만 복사합니다",
|
||
objects: "개체",
|
||
searchObjects: "개체 이름 검색...",
|
||
noObjects: "개체 없음",
|
||
objectTypeTable: "테이블",
|
||
objectTypeView: "뷰",
|
||
objectTypeMaterializedView: "구체화된 뷰",
|
||
objectTypeProcedure: "프로시저",
|
||
objectTypeFunction: "함수",
|
||
objectTypeTrigger: "트리거",
|
||
objectTypeSequence: "시퀀스",
|
||
objectTypeEvent: "이벤트",
|
||
objectDataOnlyDisabled: "데이터 전용 모드에서는 테이블이 아닌 개체는 전송되지 않습니다",
|
||
objectCrossFamilyDisabled: "데이터베이스 간 전송은 시퀀스만 지원합니다(단순 DDL, 뷰 본문은 변환되지 않음)",
|
||
crossFamilyViewHint: "데이터베이스 간 뷰 전송: 뷰가 의존하는 테이블도 선택하거나 대상 DB에 이미 존재하는지 확인하세요",
|
||
objectUnsupportedDisabled: "현재 데이터베이스는 이 개체 유형의 전송을 지원하지 않습니다",
|
||
skippedExistingObjects: "기존 개체 {count}개 건너뜀",
|
||
targetTableHandling: "대상 테이블 처리 방식",
|
||
source: "소스",
|
||
target: "대상",
|
||
sourceConnection: "소스 연결",
|
||
sourceDatabase: "소스 데이터베이스",
|
||
sourceSchema: "소스 스키마",
|
||
swap: "소스와 대상 교체",
|
||
targetConnection: "대상 연결",
|
||
targetDatabase: "대상 데이터베이스",
|
||
targetSchema: "대상 스키마",
|
||
tables: "테이블",
|
||
selectAll: "모두 선택",
|
||
deselectAll: "모두 선택 해제",
|
||
createTable: "테이블이 없으면 생성",
|
||
transferMode: "이전 모드",
|
||
modeAppend: "추가 (INSERT)",
|
||
modeOverwrite: "덮어쓰기 (TRUNCATE + INSERT)",
|
||
modeUpsert: "Upsert (PK 기준 INSERT 또는 UPDATE)",
|
||
targetTableNameCase: "대상 테이블 이름 대소문자",
|
||
quoteTargetColumnNames: "대상 열 이름 인용",
|
||
tableNameCasePreserve: "유지",
|
||
tableNameCaseLower: "소문자",
|
||
tableNameCaseUpper: "대문자",
|
||
batchSize: "배치 크기",
|
||
modeRebuild: "구조 및 데이터 재구축 (RENAME + CREATE + INSERT)",
|
||
modeKeepExisting: "기존 테이블 유지",
|
||
modeRebuildStructure: "구조 재구축 (RENAME + CREATE)",
|
||
rebuildSummary: "{count}개 테이블을 재구축합니다: 기존 대상 테이블을 먼저 백업으로 이름을 바꾸고 소스 구조로 다시 만든 뒤 데이터를 넣습니다. 모든 단계가 성공한 후 백업을 삭제합니다.",
|
||
rebuildDanger: "재구축하면 선택한 대상 테이블, 기존 행, 대상에만 있는 메타데이터가 교체됩니다. 실제 대상, 백업 이름, SQL을 확인하세요. 삭제된 백업은 복구에 사용할 수 없습니다.",
|
||
rebuildDataOnlyDisabled: "데이터만 전송할 때는 재구축할 수 없습니다. 구조 및 데이터 또는 구조만을 선택하세요.",
|
||
rebuildUnsupportedDisabled: "선택한 대상 엔진은 대상 테이블 재구축을 지원하지 않습니다.",
|
||
rebuildPreviewUnavailable: "백엔드가 재구축 계획을 반환하지 않아 전송을 시작하지 않았습니다. 재구축 미리 보기를 지원하는 백엔드에서 다시 시도하세요.",
|
||
rebuildMissingTargets: "존재하지 않는 대상 테이블이 있습니다. 백업 없이 바로 생성됩니다.",
|
||
previewFailed: "전송을 준비할 수 없습니다: {message}",
|
||
start: "이전 시작",
|
||
startConfirmTitle: "전송 시작 확인",
|
||
startConfirmMessage: "{source}에서 선택한 개체 {count}개를 {target}(으)로 전송합니다. 시작하시겠습니까?",
|
||
cancel: "취소",
|
||
progress: "이전 중...",
|
||
transferring: "{table} 이전 중...",
|
||
completed: "이전 완료",
|
||
completedWithErrors: "{count}개 테이블 실패로 완료",
|
||
failed: "이전 실패",
|
||
cancelled: "이전 취소됨",
|
||
rowsTransferred: "{count}행 이전됨",
|
||
tableProgress: "{current} / {total} 테이블",
|
||
noSqlConnections: "사용 가능한 SQL 연결이 없습니다",
|
||
selectTables: "이전할 테이블 선택",
|
||
searchTables: "테이블 검색...",
|
||
noTables: "테이블이 없습니다",
|
||
selectSourceFirst: "먼저 소스 연결과 데이터베이스를 선택하세요",
|
||
tableError: "테이블 {table} 실패: {error}",
|
||
overallProgress: "전체 진행률",
|
||
dataTransfer: "데이터 이전",
|
||
runInBackground: "백그라운드에서 실행",
|
||
newTask: "새 이전",
|
||
editConfig: "설정 편집",
|
||
retry: "다시 시도",
|
||
targetTableBusy: "다른 이전이 이미 대상 테이블에 쓰고 있습니다: {tables}",
|
||
ownershipTitle: "소유권 확인",
|
||
ownershipMessage: "대상 데이터베이스에 다음 소유자 사용자나 역할이 없습니다: {owners}. 원래 소유권을 적용하면 실패할 수 있습니다.",
|
||
ownershipSkipDetails: "건너뛰기를 선택하면 객체 소유권 변경 구문을 실행하지 않습니다. 테이블 데이터와 다른 구조 동기화는 계속됩니다.",
|
||
ownershipTargetOwner: "확인을 선택하면 소유자가 없는 객체를 대상 연결 사용자에게 재할당합니다: {owner}.",
|
||
ownershipSkip: "건너뛰기",
|
||
ownershipConfirm: "확인",
|
||
selectConnection: "연결 선택",
|
||
selectDatabase: "데이터베이스 선택",
|
||
selectSchema: "스키마 선택",
|
||
searchConnection: "연결 검색...",
|
||
searchDatabase: "데이터베이스 검색...",
|
||
searchSchema: "스키마 검색...",
|
||
saveConfig: "구성 저장",
|
||
saveAsNewTask: "작업으로 저장",
|
||
taskSaved: "작업이 저장되었습니다",
|
||
unsavedTitle: "저장되지 않은 변경 사항",
|
||
unsavedMessage: "현재 구성에 저장되지 않은 변경 사항이 있습니다. 무시하시겠습니까?",
|
||
unsavedDiscard: "변경 사항 무시",
|
||
tasks: {
|
||
title: "전송 작업",
|
||
searchTasks: "작업 검색...",
|
||
newTask: "새 작업",
|
||
newFolder: "새 폴더",
|
||
newSubfolder: "새 하위 폴더",
|
||
rename: "이름 바꾸기",
|
||
duplicate: "복제",
|
||
delete: "삭제",
|
||
open: "열기",
|
||
moveToFolder: "폴더로 이동",
|
||
ungrouped: "그룹 없음",
|
||
empty: "저장된 전송 작업이 없습니다",
|
||
newFolderDefault: "새 폴더",
|
||
newTaskDefault: "새 전송 작업",
|
||
deleteFolderTitle: "폴더 삭제",
|
||
deleteFolderConfirm: "“{name}”과(와) 그 안의 모든 전송 작업을 삭제하시겠습니까?",
|
||
deleteTaskTitle: "작업 삭제",
|
||
deleteTaskConfirm: "전송 작업 “{name}”을(를) 삭제하시겠습니까?",
|
||
nameConflict: "“{name}”이(가) 이 위치에 이미 존재합니다",
|
||
moveFailed: "이동 실패: {message}",
|
||
saveFailed: "저장 실패: {message}",
|
||
deleteFailed: "삭제 실패: {message}",
|
||
},
|
||
},
|
||
tableImport: {
|
||
title: "테이블 데이터 가져오기",
|
||
target: "대상 테이블",
|
||
selectFile: "파일 선택",
|
||
changeFile: "파일 변경",
|
||
noFileSelected: "선택한 파일이 없습니다",
|
||
sourceFile: "소스 파일",
|
||
sourceFormat: "소스 형식",
|
||
targetMode: "대상",
|
||
existingTable: "기존 테이블",
|
||
createTable: "테이블 만들기",
|
||
createTableHint: "파일에서 컬럼 추론",
|
||
targetTableName: "테이블 이름",
|
||
noExistingTarget: "선택한 테이블이 없습니다",
|
||
searchExistingTables: "테이블 검색...",
|
||
loadingTables: "테이블 불러오는 중...",
|
||
noTables: "사용 가능한 테이블이 없습니다",
|
||
stepSource: "소스",
|
||
stepOptions: "옵션",
|
||
stepMapping: "매핑",
|
||
stepReview: "검토",
|
||
stepExecution: "실행",
|
||
formatCsv: "CSV",
|
||
formatCsvDescription: "쉼표로 구분된 텍스트",
|
||
formatTsv: "TSV",
|
||
formatTsvDescription: "탭으로 구분된 텍스트",
|
||
formatDelimited: "구분자",
|
||
formatDelimitedDescription: "사용자 지정 텍스트 구분자",
|
||
formatJson: "JSON",
|
||
formatJsonDescription: "객체 또는 배열 행",
|
||
formatExcel: "Excel",
|
||
formatExcelDescription: "XLS, XLSX, XLSM",
|
||
formatSql: "SQL",
|
||
formatSqlDescription: "SQL 스크립트의 INSERT 문",
|
||
previewRows: "미리보기 행",
|
||
delimiter: "구분자",
|
||
encoding: "인코딩",
|
||
encodingAuto: "자동 감지",
|
||
encodingUtf8: "UTF-8",
|
||
encodingGbk: "GBK / GB18030",
|
||
encodingUtf16Le: "UTF-16 LE",
|
||
encodingUtf16Be: "UTF-16 BE",
|
||
encodingDetected: "감지됨: {encoding}",
|
||
hasHeader: "첫 행이 머리글",
|
||
titleRow: "제목 행 (없으면 0)",
|
||
dataStartRow: "데이터 시작 행",
|
||
lastDataRow: "마지막 데이터 행 (끝까지면 0)",
|
||
trimValues: "값 양끝 공백 제거",
|
||
emptyStringAsNull: "빈 문자열을 NULL로",
|
||
jsonShape: "JSON 행",
|
||
jsonShapeAuto: "자동 감지",
|
||
jsonShapeObjects: "객체",
|
||
jsonShapeArrays: "배열",
|
||
sheet: "시트",
|
||
firstSheet: "첫 번째 시트",
|
||
loadPreview: "미리보기 불러오기",
|
||
reloadPreview: "미리보기 다시 불러오기",
|
||
previewReady: "{rows}행, {columns}열",
|
||
previewReadyPartial: "{rows}행, {columns}열 미리보기; 전체는 가져오는 동안 확인됩니다",
|
||
previewPartial: "{rows}행 미리보기",
|
||
rowsImported: "가져온 행",
|
||
file: "파일",
|
||
rows: "행",
|
||
mapped: "매핑됨",
|
||
mapping: "컬럼 매핑",
|
||
sourceColumn: "소스",
|
||
targetColumn: "대상",
|
||
targetDataType: "타입",
|
||
createColumns: "생성할 컬럼",
|
||
skipColumn: "건너뛰기",
|
||
preview: "미리보기",
|
||
mode: "가져오기 모드",
|
||
append: "데이터 추가",
|
||
truncate: "비우고 가져오기",
|
||
progress: "진행률",
|
||
start: "가져오기 시작",
|
||
success: "{count}행 가져옴",
|
||
elapsed: "경과 {duration}",
|
||
back: "뒤로",
|
||
next: "다음",
|
||
truncateWarning: "가져오기를 시작하기 전에 대상 테이블의 기존 행이 제거됩니다.",
|
||
requiredUnmapped: "필수 대상 컬럼이 매핑되지 않았습니다: {columns}",
|
||
status_idle: "가져오기 준비됨",
|
||
status_running: "데이터 가져오는 중",
|
||
phase_preparing: "가져오기 준비 중",
|
||
phase_detectingEncoding: "텍스트 인코딩 감지 중",
|
||
phase_reading: "소스 파일 읽는 중",
|
||
phase_writing: "데이터 쓰는 중",
|
||
phase_finalizing: "가져오기 마무리 중",
|
||
status_done: "가져오기 완료",
|
||
status_error: "가져오기 실패",
|
||
status_cancelled: "가져오기 취소됨",
|
||
targetColumnsTimeout: "대상 테이블 필드를 로드하는 시간이 초과되었습니다. 연결을 확인한 후 다시 시도하십시오.",
|
||
retry: "재시도",
|
||
},
|
||
dataGenerate: {
|
||
title: "데이터 생성",
|
||
target: "대상",
|
||
rowCount: "생성할 행 수",
|
||
columns: "컬럼",
|
||
column: "컬럼",
|
||
type: "타입",
|
||
generator: "생성기",
|
||
columnProps: "컬럼 속성",
|
||
databaseObjects: "데이터베이스 객체",
|
||
selectTable: "왼쪽에서 테이블을 선택하세요",
|
||
saveProfile: "프로필 저장",
|
||
loadProfile: "프로필 불러오기",
|
||
options: "옵션",
|
||
generateOrder: "생성 순서",
|
||
nextStep: "다음",
|
||
insertSuccess: "{count}행 삽입됨",
|
||
noData: "아직 데이터가 없습니다. 먼저 생성 규칙을 구성하세요",
|
||
noResult: "실행 결과가 없습니다",
|
||
regenerate: "다시 생성",
|
||
first50Rows: "처음 50행 표시 중, 전체 {count}행",
|
||
resultTitle: "실행 결과",
|
||
successLabel: "{count}개 성공",
|
||
failLabel: "{count}개 실패",
|
||
totalLabel: "/ {count}개 항목",
|
||
copySampleSql: "샘플 SQL 복사",
|
||
prevStep: "이전",
|
||
startInsert: "삽입 시작",
|
||
confirm: "확인",
|
||
back: "뒤로",
|
||
reset: "재설정",
|
||
selectGenerator: "생성기 선택...",
|
||
selectGeneratorHint: "생성기를 선택하세요",
|
||
preview: "미리보기",
|
||
noValue: "(없음)",
|
||
startDate: "시작 날짜",
|
||
endDate: "종료 날짜",
|
||
allDay: "하루 종일",
|
||
startTime: "시작 시간",
|
||
endTime: "종료 시간",
|
||
weekday: "요일",
|
||
all: "전체",
|
||
weekdayOnly: "평일",
|
||
custom: "사용자 지정",
|
||
values: "값",
|
||
min: "최소",
|
||
max: "최대",
|
||
increment: "증가분",
|
||
cycle: "초과 시 순환",
|
||
includeDefault: "DEFAULT 포함",
|
||
includeNull: "NULL 포함",
|
||
unique: "고유 설정",
|
||
uniqueExhausted: "{attempts}번 시도했지만 {table}.{column}의 중복되지 않는 값을 생성하지 못했습니다. 값 범위를 늘리거나 생성 행 수를 줄이세요.",
|
||
disableLinks: "컬럼 간 데이터 연결 비활성화",
|
||
imageMode: "모드",
|
||
generate: "생성",
|
||
fromFolder: "폴더에서",
|
||
imageWidth: "이미지 너비",
|
||
imageHeight: "이미지 높이",
|
||
imageFormat: "이미지 형식",
|
||
folderPath: "폴더 경로",
|
||
filterByExtension: "확장자로 필터",
|
||
errorContinue: "오류 시 계속",
|
||
truncateBefore: "생성 전 테이블 비우기",
|
||
useTransaction: "트랜잭션 사용",
|
||
extendedInsert: "확장 INSERT 사용",
|
||
ok: "확인",
|
||
noTablesSelected: "선택한 테이블이 없습니다",
|
||
orderHint: "화살표 버튼으로 순서 변경",
|
||
language: "언어",
|
||
regionLabel: "지역",
|
||
formatLabel: "형식",
|
||
formatType: "형식 유형",
|
||
typeLabel: "유형",
|
||
loading: "불러오는 중...",
|
||
regex: "정규 표현식",
|
||
rawPattern: "원시 패턴 모드",
|
||
notSet: "(설정 안 됨)",
|
||
noMatch: "(일치 없음)",
|
||
invalidRegex: "(잘못된 정규 표현식)",
|
||
noDomain: "(도메인 없음)",
|
||
schema: "스키마",
|
||
tableLabel: "테이블",
|
||
columnLabel: "컬럼",
|
||
genMode: "생성 모드",
|
||
dateType: "날짜 유형",
|
||
yearOffsetRange: "연도 범위 (현재 연도 기준 오프셋)",
|
||
numberType: "숫자 유형",
|
||
integer: "정수",
|
||
decimal: "소수",
|
||
decimalPlaces: "소수점 자릿수",
|
||
uuidFormat: "UUID 형식",
|
||
uuidWithHyphens: "하이픈 포함",
|
||
uuidNoHyphens: "하이픈 없음",
|
||
includeSeparators: "구분자 포함",
|
||
phoneDomestic: "국내",
|
||
phoneInternational: "국제",
|
||
charCount: "문자 수",
|
||
start: "시작",
|
||
valueList: "값 목록",
|
||
domainList: "도메인 목록",
|
||
subdomains: "하위 도메인",
|
||
tlds: "최상위 도메인",
|
||
extensionType: "확장자 유형",
|
||
extensionList: "확장자 목록:",
|
||
availableExtensions: "사용 가능한 확장자:",
|
||
includeExtension: "확장자 포함",
|
||
includeFileName: "파일 이름 포함",
|
||
pathType: "경로 유형",
|
||
ipType: "IP 주소 유형",
|
||
nameFormat: "이름 형식",
|
||
transformTo: "값 변환",
|
||
generateOptions: "생성 옵션",
|
||
previewRowCount: "{count}행",
|
||
useKeywords: "키워드에서 생성",
|
||
weekdayShort: {
|
||
sun: "일",
|
||
mon: "월",
|
||
tue: "화",
|
||
wed: "수",
|
||
thu: "목",
|
||
fri: "금",
|
||
sat: "토",
|
||
},
|
||
countries: {
|
||
us: "미국",
|
||
uk: "영국",
|
||
cn: "중국",
|
||
jp: "일본",
|
||
other: "기타",
|
||
cnEnglish: "중국 (영어)",
|
||
jpEnglish: "일본 (영어)",
|
||
},
|
||
cityLanguages: {
|
||
native: "현지 언어",
|
||
english: "영어",
|
||
},
|
||
addressTypes: {
|
||
line1: "주소 1",
|
||
line2: "주소 2",
|
||
full: "전체 주소",
|
||
},
|
||
nameFormats: {
|
||
full: "전체 이름",
|
||
last: "성만",
|
||
first: "이름만",
|
||
},
|
||
regionFormats: {
|
||
name: "이름",
|
||
code: "코드",
|
||
codeName: "코드 + 이름",
|
||
},
|
||
transforms: {
|
||
none: "그대로",
|
||
upper: "대문자",
|
||
lower: "소문자",
|
||
title: "제목형",
|
||
},
|
||
extensionCategories: {
|
||
image: "이미지",
|
||
document: "문서",
|
||
spreadsheet: "스프레드시트",
|
||
presentation: "프레젠테이션",
|
||
audio: "오디오",
|
||
video: "비디오",
|
||
code: "코드",
|
||
archive: "압축 파일",
|
||
web: "웹",
|
||
database: "데이터베이스",
|
||
},
|
||
placeholders: {
|
||
enumValues: "한 줄에 하나의 값\nfirst\nsecond\nthird",
|
||
subdomains: "한 줄에 하나의 하위 도메인\nauth.\nwww.\napi.",
|
||
tlds: "한 줄에 하나의 TLD\n.com\n.cn\n.io",
|
||
fileExtensions: "한 줄에 하나의 확장자\npng\njpg\ntxt",
|
||
paymentMethods: "한 줄에 하나의 결제 수단\nCredit Card\nPayPal\nApple Pay",
|
||
keywords: "한 줄에 하나의 키워드\nApple\nCherry\nOrange",
|
||
weightUnits: "한 줄에 하나의 단위\ng\nkg\nlb",
|
||
},
|
||
genModes: {
|
||
random: "무작위",
|
||
unique: "중복 없음",
|
||
repeat: "각 값 반복",
|
||
},
|
||
gen: {
|
||
general: "일반",
|
||
personal: "개인",
|
||
payment: "결제",
|
||
business: "비즈니스",
|
||
location: "위치",
|
||
product: "제품",
|
||
computer: "컴퓨터",
|
||
number: "숫자",
|
||
datetime: "날짜/시간",
|
||
date: "날짜",
|
||
time: "시간",
|
||
sequence: "시퀀스",
|
||
enum: "Enum",
|
||
text: "텍스트",
|
||
image: "이미지 또는 바이너리",
|
||
foreign_key: "외래 키",
|
||
uuid: "UUID",
|
||
regex: "정규 표현식",
|
||
full_name: "전체 이름",
|
||
gender: "성별",
|
||
title: "칭호",
|
||
marital_status: "결혼 여부",
|
||
phone: "전화번호",
|
||
email: "이메일",
|
||
job_title: "직함",
|
||
social_id: "사회 보장 번호",
|
||
payment_method: "결제 수단",
|
||
credit_card_type: "신용카드 유형",
|
||
credit_card_number: "신용카드 번호",
|
||
credit_card_date: "신용카드 날짜",
|
||
company_name: "회사 이름",
|
||
department: "부서",
|
||
industry: "산업",
|
||
address: "주소",
|
||
city: "도시",
|
||
region: "지역",
|
||
product_name: "제품 이름",
|
||
product_category: "제품 카테고리",
|
||
color: "색상",
|
||
size: "크기",
|
||
weight_unit: "무게 단위",
|
||
barcode: "바코드",
|
||
sku: "SKU",
|
||
ip_address: "IP 주소",
|
||
mac_address: "MAC 주소",
|
||
file_path: "파일 경로",
|
||
file_name: "파일 이름",
|
||
file_extension: "파일 확장자",
|
||
url: "URL",
|
||
hostname: "호스트 이름",
|
||
id_number: "ID 번호",
|
||
},
|
||
idTypes: {
|
||
title: "ID 유형",
|
||
customPattern: "사용자 지정 패턴",
|
||
customPatternPlaceholder: "예: ([A-Z]{'{'}2{'}'})-([0-9]{'{'}8{'}'})",
|
||
customPatternHint: "[A-Z] 문자, [0-9] 숫자, {'{'}n{'}'} 반복, 하이픈 등 단순 패턴을 지원합니다",
|
||
id_card: "중국 주민등록증",
|
||
passport: "여권",
|
||
hk_macau_pass: "홍콩/마카오 통행증",
|
||
taiwan_pass: "대만 통행증",
|
||
uscc: "통합사회신용코드",
|
||
bank_card: "은행 카드",
|
||
drivers_license: "운전면허증",
|
||
custom: "사용자 지정",
|
||
},
|
||
insertingTable: "{table}에 쓰는 중 (표 {index}/{count})",
|
||
elapsed: "{seconds}초 경과",
|
||
samplePreviewNotice: "앞의 {shown}행은 예시입니다. 전체 {count}행은 삽입할 때 생성됩니다",
|
||
largeRowCountHint: "행 수가 많습니다({count}행). 배치로 생성과 삽입을 진행하며 언제든 취소할 수 있습니다",
|
||
timeoutSecs: "제한 시간(초)",
|
||
timeoutHint: "0이면 제한 시간 없음입니다. 대량 데이터에서는 0을 유지하거나 더 길게 설정하세요",
|
||
batchRows: "배치당 행 수",
|
||
batchRowsHint: "한 번에 생성하고 삽입할 행 수입니다. 서버 한도를 넘으면 자동으로 분할됩니다",
|
||
cancelInsert: "삽입 취소",
|
||
cancelledLabel: "취소되었습니다. 이미 삽입된 행은 테이블에 남습니다",
|
||
},
|
||
tableToolbox: {
|
||
title: "데이터 도구",
|
||
generateData: "데이터 생성",
|
||
importData: "데이터 가져오기",
|
||
exportData: "데이터 내보내기",
|
||
generateDataComingSoon: "준비 중",
|
||
},
|
||
sqlFile: {
|
||
restoreScope: "복원 범위",
|
||
restoreAll: "모든 내용",
|
||
restoreSelectedTables: "선택한 테이블",
|
||
restoreTablesOnly: "테이블 구조와 데이터만 복원합니다. 뷰, 저장 프로시저, 함수, 트리거 및 이벤트는 제외됩니다. 기존 외래 키와 트리거가 복원에 영향을 줄 수 있습니다.",
|
||
scanningTables: "백업의 테이블을 검색하는 중...",
|
||
searchBackupTables: "백업의 테이블 검색...",
|
||
selectVisibleTables: "표시된 테이블 선택",
|
||
selectedTableCount: "테이블 {selected} / {total}개 선택됨",
|
||
noBackupTables: "백업에 일치하는 테이블이 없습니다",
|
||
title: "SQL 파일 실행",
|
||
file: "파일",
|
||
selectSqlFile: "SQL 파일 선택",
|
||
browse: "찾아보기",
|
||
previewingLines: "{count}줄 미리보는 중",
|
||
previewingFirstLines: "처음 {count}줄 미리보는 중",
|
||
tooLargeForEditor: "이 SQL 파일은 {size}(이)가 되어 편집기 한도인 {limit}을(를) 초과합니다. 스트림으로 처리하려면 SQL 파일 실행을 사용하세요.",
|
||
largeFileExecutionOpened: "이 {size} SQL 파일은 편집기에 너무 큽니다. 스트리밍용 SQL 파일 실행이 열렸습니다.",
|
||
target: "대상",
|
||
connection: "연결",
|
||
selectConnection: "연결 선택",
|
||
database: "데이터베이스",
|
||
selectDatabase: "데이터베이스 선택",
|
||
databasePlaceholder: "데이터베이스 이름",
|
||
options: "옵션",
|
||
continueOnError: "오류 시 계속",
|
||
runInBackground: "백그라운드에서 실행",
|
||
cancelling: "취소하는 중...",
|
||
cancel: "취소",
|
||
execute: "실행",
|
||
statement: "구문",
|
||
succeeded: "성공",
|
||
failed: "실패",
|
||
affectedRows: "영향 받은 행",
|
||
currentStatement: "현재 구문",
|
||
status: {
|
||
idle: "대기",
|
||
started: "시작됨",
|
||
running: "실행 중",
|
||
statementDone: "구문 완료",
|
||
statementFailed: "구문 실패",
|
||
done: "완료",
|
||
error: "오류",
|
||
cancelled: "취소됨",
|
||
},
|
||
fileProgress: "파일 {current}/{total}",
|
||
fileColumn: "파일",
|
||
totalFiles: "{count}개 파일",
|
||
},
|
||
sqlFileTree: {
|
||
title: "SQL 파일",
|
||
openFolder: "폴더 열기",
|
||
closePanel: "닫기",
|
||
loading: "불러오는 중...",
|
||
noFolder: "열린 폴더가 없습니다",
|
||
noSqlFiles: "SQL 파일이 없습니다",
|
||
folderAlreadyOpen: "이 폴더는 이미 열려 있습니다",
|
||
removeFolder: "폴더 제거",
|
||
openFailed: "폴더를 여는 데 실패했습니다: {message}",
|
||
loadFailed: "SQL 파일을 불러오는 데 실패했습니다: {message}",
|
||
desktopOnly: "이 기능은 데스크톱에서만 사용할 수 있습니다",
|
||
refreshFolder: "폴더 새로고침",
|
||
refreshAll: "모두 새로고침",
|
||
refreshed: "새로고침했습니다",
|
||
revealInFileManager: "파일 관리자에서 보기",
|
||
revealFailed: "파일 관리자를 여는 데 실패했습니다: {message}",
|
||
copyPath: "경로 복사",
|
||
pathCopied: "경로를 복사했습니다",
|
||
copyFailed: "경로 복사에 실패했습니다",
|
||
openFile: "열기",
|
||
executeSqlFile: "SQL 파일 실행",
|
||
newSqlFile: "새 SQL 파일",
|
||
newSqlFileDescription: ".sql 확장자가 자동으로 추가됩니다.",
|
||
createFile: "생성",
|
||
fileCreated: "SQL 파일을 생성했습니다",
|
||
createFailed: "SQL 파일을 생성하지 못했습니다: {message}",
|
||
renameFile: "이름 바꾸기",
|
||
renameFileDescription: ".sql 확장자가 자동으로 추가됩니다.",
|
||
fileRenamed: "SQL 파일 이름을 변경했습니다",
|
||
renameFailed: "SQL 파일 이름을 변경하지 못했습니다: {message}",
|
||
deleteFile: "파일 삭제",
|
||
deleteFileConfirm: "{name}을(를) 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.",
|
||
fileDeleted: "SQL 파일을 삭제했습니다",
|
||
deleteFailed: "SQL 파일을 삭제하지 못했습니다: {message}",
|
||
expandAll: "모두 펼치기",
|
||
collapseAll: "모두 접기",
|
||
filterSettings: "파일 필터",
|
||
fileFilter: "파일 이름 필터",
|
||
fileFilterPlaceholder: "파일 이름 필터",
|
||
filterInvalid: "파일 필터가 잘못되어 이전 설정을 유지합니다: {message}",
|
||
fileFilterHint: "*.sql 또는 *.sh 같은 와일드카드나 {regex} 같은 정규식을 사용할 수 있습니다.",
|
||
},
|
||
diff: {
|
||
progress: {
|
||
loadingObjects: "원본 및 대상 데이터베이스 객체를 읽는 중...",
|
||
loadingSourceDetails: "원본 데이터베이스 테이블 구조를 읽는 중",
|
||
loadingTargetDetails: "대상 데이터베이스 테이블 구조를 읽는 중",
|
||
loadingExtraObjects: "기타 데이터베이스 객체를 읽는 중...",
|
||
comparing: "스키마 차이를 분석하는 중...",
|
||
generating: "비교 결과를 생성하는 중...",
|
||
next: "다음 단계: {step}",
|
||
nextSourceDetails: "원본 데이터베이스 테이블 구조 읽기",
|
||
nextTargetDetails: "대상 데이터베이스 테이블 구조 읽기",
|
||
nextExtraObjects: "기타 데이터베이스 객체 읽기",
|
||
nextComparing: "스키마 차이 분석",
|
||
nextGenerating: "비교 결과 생성",
|
||
nextComplete: "완료",
|
||
count: "{current} / {total}",
|
||
},
|
||
title: "스키마 비교",
|
||
source: "소스",
|
||
target: "대상",
|
||
selectConnection: "연결 선택",
|
||
selectDatabase: "데이터베이스 선택",
|
||
selectSchema: "스키마 선택",
|
||
connection: "연결",
|
||
database: "데이터베이스",
|
||
schema: "스키마",
|
||
recentConfigs: "최근 설정",
|
||
selectRecentConfig: "최근 설정 선택",
|
||
ignoreComments: "주석 차이 무시",
|
||
compare: "비교",
|
||
comparing: "스키마를 비교하는 중...",
|
||
noDifferences: "차이점이 없습니다",
|
||
table: "테이블",
|
||
status: "상태",
|
||
details: "상세",
|
||
added: "추가됨",
|
||
removed: "제거됨",
|
||
modified: "수정됨",
|
||
indexes: "인덱스",
|
||
foreignKeys: "외래 키",
|
||
triggers: "트리거",
|
||
comments: "주석",
|
||
newTable: "새 테이블",
|
||
dropTable: "테이블 삭제",
|
||
generatedSql: "동기화 SQL",
|
||
copySql: "SQL 복사",
|
||
executeSync: "동기화 실행",
|
||
syncSuccess: "동기화를 성공적으로 실행했습니다",
|
||
swap: "소스와 대상 교체",
|
||
syncProgress: "실행 중: {current}/{total}",
|
||
syncSummary: "성공 {success}, 실패 {failed}",
|
||
configSaved: "설정을 저장했습니다",
|
||
configDeleted: "설정을 삭제했습니다",
|
||
comparisonObjects: "비교 객체",
|
||
searchObjects: "객체 이름 검색...",
|
||
selectAllObjects: "모두 선택",
|
||
deselectAllObjects: "선택 해제",
|
||
objectPickerAll: "전체",
|
||
objectGroupDisabled: "이 객체 유형은 비교에 포함되지 않습니다.",
|
||
noObjects: "객체 없음",
|
||
noObjectMatches: "일치 항목 없음",
|
||
tableSelection: "테이블",
|
||
chooseTables: "테이블 선택...",
|
||
compareAllTables: "모든 테이블 비교",
|
||
tableSelectionUnrestricted: "정규식 필터 후 모든 테이블을 비교합니다. 특정 테이블을 선택하면 비교 범위를 제한할 수 있습니다.",
|
||
sourceTables: "소스 테이블",
|
||
targetTable: "대상 테이블",
|
||
sourceTable: "소스 테이블",
|
||
similarity: "유사도",
|
||
autoMatchHint: "대상 테이블은 같은 이름으로 자동 매칭됩니다.",
|
||
matchedTables: "{matched}/{total}개 테이블 매칭됨",
|
||
missingTargetTables: "같은 이름의 대상 테이블 누락: {tables}",
|
||
targetTableMatching: "대상 테이블 매핑",
|
||
selectTargetTable: "대상 테이블 선택",
|
||
searchTargetTable: "대상 테이블 검색...",
|
||
noTargetTables: "사용 가능한 대상 테이블이 없습니다",
|
||
tableMatchStatus: {
|
||
automatic: "자동 매칭",
|
||
manual: "수동 매칭",
|
||
unmatched: "매칭되지 않음",
|
||
},
|
||
unmatchedTableWarning: "선택한 소스 테이블 중 {count}개에 대상 매핑이 없습니다",
|
||
targetTableInUse: "이 대상 테이블은 다른 소스 테이블에서 이미 사용 중입니다",
|
||
sourceObject: "소스 객체",
|
||
targetObject: "대상 객체",
|
||
operation: "작업",
|
||
selectedCount: "{total}개 중 {selected}개 선택",
|
||
saveConfig: "설정 저장",
|
||
loadConfig: "설정 불러오기",
|
||
options: "옵션",
|
||
ddlCompare: "DDL 비교",
|
||
deployScript: "배포 스크립트",
|
||
deployScriptAll: "모든 배포 스크립트",
|
||
deployScriptDesc: "선택한 객체의 SQL 스크립트",
|
||
deployScriptAllDesc: "선택한 모든 객체의 SQL 스크립트",
|
||
copy: "복사",
|
||
execute: "실행",
|
||
executeAll: "모두 실행",
|
||
executeSuccess: "성공적으로 실행했습니다",
|
||
selectObjectToCompare: "DDL 비교를 보려면 객체를 선택하세요",
|
||
noDdlAvailable: "사용 가능한 DDL이 없습니다",
|
||
noDeployScript: "배포 스크립트 없음",
|
||
noDeployScriptAll: "선택한 객체에 대한 배포 스크립트가 없습니다",
|
||
sourceDdl: "소스 DDL",
|
||
targetDdl: "대상 DDL",
|
||
objectNotExistsInSource: "이 객체는 소스 데이터베이스에 존재하지 않습니다",
|
||
objectNotExistsInTarget: "이 객체는 대상 데이터베이스에 존재하지 않습니다",
|
||
nextStepDeploy: "다음 (배포 검토)",
|
||
deployReview: "배포 검토",
|
||
backToResult: "결과로 돌아가기",
|
||
copyScript: "스크립트 복사",
|
||
exportSql: ".sql 내보내기",
|
||
deployToServer: "서버에 배포",
|
||
deployConfirmTitle: "최종 확인",
|
||
deployConfirmMessage: "다음 변경 사항을 대상 데이터베이스에 배포하려고 합니다",
|
||
destructiveSqlDetected: "파괴적인 작업 {count}개가 감지되었습니다. 명시적인 확인이 필요합니다",
|
||
compatibilityWarnings: "호환성 경고",
|
||
compatibilityWarningsDetected: "호환성 경고: {count}개",
|
||
targetServer: "대상 서버",
|
||
dbVersion: "데이터베이스 버전",
|
||
targetDatabase: "대상 데이터베이스",
|
||
targetSchema: "대상 스키마",
|
||
useTransaction: "트랜잭션으로 실행 (실패 시 자동 롤백)",
|
||
confirmDeploy: "배포 확인",
|
||
exportSuccess: "내보내기 성공",
|
||
create: "생성",
|
||
delete: "삭제",
|
||
modify: "수정",
|
||
cancel: "취소",
|
||
prevStep: "이전",
|
||
recompare: "다시 비교",
|
||
maximize: "최대화",
|
||
restore: "복원",
|
||
operationLabel: {
|
||
modify: "수정할 객체",
|
||
create: "생성할 객체",
|
||
delete: "삭제할 객체",
|
||
none: "작업 없음",
|
||
},
|
||
objectKindLabel: {
|
||
table: "테이블",
|
||
view: "뷰",
|
||
function: "함수",
|
||
sequence: "시퀀스",
|
||
rule: "룰",
|
||
owner: "소유자",
|
||
column: "열",
|
||
index: "인덱스",
|
||
foreignKey: "외래 키",
|
||
trigger: "트리거",
|
||
tableOption: "테이블 옵션",
|
||
},
|
||
noObjectsSelected: "배포할 객체를 선택하세요",
|
||
deploySuccess: "배포 성공",
|
||
deployFailed: "배포 실패",
|
||
deploySuccessMessage: "대상 데이터베이스에서 SQL 스크립트를 성공적으로 실행했습니다",
|
||
deployFailedMessage: "실행 중 오류가 발생했습니다",
|
||
affectedRows: "영향 받은 행",
|
||
executedStatements: "실행된 구문",
|
||
serverVersion: "서버 버전",
|
||
info: "정보",
|
||
connType: "연결 유형",
|
||
connName: "연결 이름",
|
||
host: "호스트",
|
||
port: "포트",
|
||
copied: "클립보드에 복사했습니다",
|
||
saveConfigPrompt: "설정 이름을 입력하세요:",
|
||
defaultConfigName: "기본값",
|
||
dependsOn: "다음에 종속",
|
||
dependedBy: "다음에 의해 종속됨",
|
||
close: "닫기",
|
||
searchConnection: "연결 검색...",
|
||
searchDatabase: "데이터베이스 검색...",
|
||
searchSchema: "스키마 검색...",
|
||
openFieldMapping: "필드 매핑",
|
||
fieldMapping: {
|
||
title: "필드 타입 매핑",
|
||
sameTypeHint: "소스와 대상이 같은 데이터베이스 유형입니다. 필드 매핑은 서로 다른 데이터베이스 유형을 비교할 때만 필요합니다.",
|
||
preset: "내장 프리셋",
|
||
selectPreset: "프리셋 선택...",
|
||
noMappings: "정의된 필드 매핑이 없습니다",
|
||
sourceType: "소스 타입",
|
||
targetType: "대상 타입",
|
||
paramStrategy: "매개변수 전략",
|
||
strategyPreserve: "유지",
|
||
strategyStrip: "제거",
|
||
strategyCustom: "사용자 지정",
|
||
customParamsPlaceholder: "예: (100)",
|
||
addMapping: "매핑 추가",
|
||
autoGenerate: "자동 생성",
|
||
import: "가져오기",
|
||
export: "내보내기",
|
||
done: "완료",
|
||
importTypeMismatch: "가져온 매핑은 {src} → {tgt}용으로 내보내졌지만, 현재 비교는 {curSrc} → {curTgt}입니다. 타입 매핑이 정확하지 않을 수 있습니다. 그래도 계속하시겠습니까?",
|
||
importSuccess: "필드 매핑을 성공적으로 가져왔습니다",
|
||
importError: "필드 매핑 가져오기에 실패했습니다. JSON 형식을 확인하세요.",
|
||
clearMappings: "지우기",
|
||
staleMappingWarning: "데이터베이스 유형이 {prevSrc} → {prevTgt}에서 {curSrc} → {curTgt}(으)로 변경되었습니다. 기존 필드 매핑이 더 이상 유효하지 않을 수 있습니다. 지우시겠습니까?",
|
||
},
|
||
deployMode: "배포",
|
||
forwardSql: "순방향 SQL",
|
||
rollbackSql: "롤백 SQL",
|
||
rollbackMode: "롤백",
|
||
deployMixed: "배포가 부분적으로 완료되었습니다. 일부 구문이 이미 적용되었을 수 있습니다 ({executedCount}/{statementCount}). DDL은 트랜잭션을 지원하지 않을 수 있습니다.",
|
||
deployRolledBack: "모든 변경 사항이 롤백되었습니다.",
|
||
rollbackIncompleteBlocked: "롤백 SQL이 불완전합니다 (객체 누락). 실행이 차단되었습니다.",
|
||
rollbackIncompleteBanner: "롤백이 불완전합니다 — 트리거/테이블 DDL이 누락되었습니다. 실행 전에 누락된 객체를 수정하세요.",
|
||
deployMixedTitle: "부분 배포됨",
|
||
deployRolledBackTitle: "롤백됨",
|
||
deployMixedWarning: "일부 구문은 이미 적용되었고 다른 일부는 실패했을 수 있습니다. 데이터베이스가 불일치 상태일 수 있습니다. 트랜잭션 로그를 검토하고 다시 시도하기 전에 수동으로 조치를 취하세요.",
|
||
compareTablesSwitch: "테이블 비교",
|
||
tableCompareDisabled: "테이블 비교가 꺼져 있습니다. 스위치를 켜면 테이블이 포함됩니다.",
|
||
routineSelection: "루틴",
|
||
chooseRoutines: "루틴 선택...",
|
||
compareAllRoutines: "모든 루틴 비교",
|
||
compareRoutinesSwitch: "루틴 비교",
|
||
routineCompareDisabled: "루틴 비교가 꺼져 있습니다. 스위치를 켜면 프로시저와 함수가 포함됩니다.",
|
||
routineSelectionUnrestricted: "모든 함수와 프로시저를 비교합니다. 특정 루틴을 선택하면 비교 범위를 제한할 수 있습니다.",
|
||
routineSelectionTooLarge: "이 스키마에 루틴이 {count}개 있습니다(미선택 시 한도 {limit}). 비교 전에 루틴을 선택하세요.",
|
||
routineSelectionNeedSource: "루틴을 선택하려면 먼저 소스 연결과 데이터베이스를 선택하세요.",
|
||
routineSelectionUnsupported: "프로시저/함수 비교는 양쪽이 같은 지원 방언(MySQL, SQL Server 또는 PostgreSQL 계열)이어야 합니다.",
|
||
routineSameNameMatchingOnly: "루틴은 같은 이름(및 시그니처)으로 매칭됩니다. 이 버전에서는 수동 이름 변경 매핑을 사용할 수 없습니다.",
|
||
sourceRoutines: "소스 루틴",
|
||
noRoutines: "루틴 없음",
|
||
targetRoutineMatching: "대상 루틴 매칭",
|
||
matchedRoutines: "{matched}/{total}개 루틴 매칭됨",
|
||
selectTargetRoutine: "대상 루틴 선택",
|
||
searchSourceRoutines: "객체 검색...",
|
||
searchTargetRoutine: "대상 루틴 검색...",
|
||
noTargetRoutines: "사용 가능한 대상 루틴이 없습니다",
|
||
unmatchedRoutineWarning: "선택한 소스 루틴 {count}개에 같은 이름의 대상이 없습니다",
|
||
targetRoutineInUse: "이 대상 루틴은 이미 다른 소스 루틴에서 사용 중입니다",
|
||
targetRoutine: "대상 루틴",
|
||
resultTabTables: "테이블 ({count})",
|
||
resultTabRoutines: "루틴 ({count})",
|
||
nextStepDeployRoutines: "다음 (루틴 배포 검토)",
|
||
routineSyncDeferredHint: "루틴 동기화/배포는 아직 사용할 수 없습니다. 여기서 정의를 비교하고 DDL을 복사해 수동으로 적용하세요.",
|
||
dependencyGraph: "의존성 그래프",
|
||
routineDiffPoints: "차이점",
|
||
routineDiffStats: "+{added} −{removed} ~{modified}",
|
||
selectRoutineToCompare: "정의를 비교할 루틴을 선택하세요",
|
||
routinesNotCompared: "루틴 비교가 꺼져 있습니다. 루틴 스위치를 켠 뒤 다시 비교하세요.",
|
||
routineDdlCopied: "DDL을 복사했습니다",
|
||
copySourceDdl: "소스 DDL 복사",
|
||
copyTargetDdl: "대상 DDL 복사",
|
||
},
|
||
rollbackComparison: {
|
||
title: "롤백 비교",
|
||
forwardSql: "순방향 SQL",
|
||
rollbackSql: "롤백 SQL",
|
||
},
|
||
schemaDiff: {
|
||
optionsTitle: "비교 옵션",
|
||
selectConfig: "설정 선택",
|
||
newConfigName: "새 설정",
|
||
newConfig: "새 설정",
|
||
renameConfig: "설정 이름 변경",
|
||
duplicateConfig: "설정 복제",
|
||
deleteConfig: "설정 삭제",
|
||
exportConfig: "설정 내보내기",
|
||
exportAllConfigs: "모든 설정 내보내기",
|
||
importConfig: "설정 가져오기",
|
||
importFromFile: "파일에서 가져오기",
|
||
importFromText: "텍스트에서 가져오기",
|
||
importPlaceholder: "JSON 설정 붙여넣기...",
|
||
importInvalidJson: "잘못된 JSON 형식",
|
||
configName: "설정 이름",
|
||
tableFilter: "테이블 필터",
|
||
tableFilterHint: "정규 표현식으로 전체 테이블 이름을 일치시킵니다. /.../는 입력하지 마세요. ^는 시작, $는 끝, |는 또는을 의미합니다.",
|
||
tableFilterHintShort: "테이블 이름 정규식으로 비교 제한",
|
||
tableFilterHelp: "테이블 필터 도움말",
|
||
tableFilterHelpRule: "전체 테이블 이름을 일치시킵니다. /.../는 입력하지 마세요.",
|
||
tableFilterHelpBlank: "빈 포함은 모든 테이블을 의미합니다. 빈 제외는 제외 항목이 없음을 의미합니다.",
|
||
tableFilterHelpExample: "^user_는 user_로 시작을, _bak$는 _bak로 끝을, a|b는 a 또는 b를 의미합니다.",
|
||
tableIncludePattern: "일치하는 테이블만 비교",
|
||
tableIncludePatternPlaceholder: "예: ^user_",
|
||
tableExcludePattern: "일치하는 테이블 건너뛰기",
|
||
tableExcludePatternPlaceholder: "예: _bak$",
|
||
tableFilterPriority: "둘 다 일치할 때",
|
||
tableFilterPriorityExclude: "제외 우선",
|
||
tableFilterPriorityInclude: "포함 우선",
|
||
options: {
|
||
tables: "테이블 비교",
|
||
primaryKeys: "기본 키 비교",
|
||
foreignKeys: "외래 키 비교",
|
||
uniqueKeys: "고유 키 비교",
|
||
checks: "체크 제약 조건 비교",
|
||
exclusions: "제외 제약 조건 비교",
|
||
views: "뷰 비교",
|
||
functions: "함수 비교",
|
||
indexes: "인덱스 비교",
|
||
sequences: "시퀀스 비교",
|
||
triggers: "트리거 비교",
|
||
rules: "룰 비교",
|
||
owners: "소유자 비교",
|
||
cascadeDelete: "CASCADE 삭제 사용",
|
||
sequenceLastValues: "시퀀스 마지막 값 비교",
|
||
compareColumnOrder: "컬럼 순서 비교",
|
||
ignoreTableNameCase: "테이블 이름 대소문자 무시",
|
||
ignoreColumnNameCase: "컬럼 이름 대소문자 무시",
|
||
detectRenames: "이름 변경 감지",
|
||
detectTableRenames: "테이블 이름 변경 감지",
|
||
enableRollback: "롤백 활성화",
|
||
advancedSection: "고급",
|
||
renameThreshold: "이름 변경 임계값",
|
||
compatibilityThreshold: "호환성 임계값",
|
||
sourceDialect: "소스 방언",
|
||
targetDialect: "대상 방언",
|
||
batchSection: "일괄",
|
||
batchPatterns: "테이블 패턴 (쉼표로 구분)",
|
||
dialectAuto: "자동",
|
||
},
|
||
},
|
||
dataCompare: {
|
||
title: "데이터 비교",
|
||
selectTable: "테이블 선택",
|
||
searchTable: "테이블 검색...",
|
||
sourceTables: "소스 테이블",
|
||
targetTable: "대상 테이블",
|
||
searchTables: "테이블 검색...",
|
||
selectedTables: "{selected}/{total} 선택됨",
|
||
selectAllTables: "모두 선택",
|
||
deselectAllTables: "모두 선택 해제",
|
||
selectSourceTables: "먼저 소스 연결과 데이터베이스를 선택한 후 비교할 테이블을 선택하세요",
|
||
noTables: "비교할 수 있는 테이블이 없습니다",
|
||
autoMatchHint: "일괄 모드는 같은 이름의 대상 테이블을 자동으로 매칭합니다",
|
||
matchedTables: "{matched}/{total}개 테이블 매칭됨",
|
||
missingTargetTables: "같은 이름의 대상 테이블 누락: {tables}",
|
||
keyColumns: "키 컬럼",
|
||
keyColumnsPlaceholder: "쉼표로 구분된 기본 또는 고유 컬럼",
|
||
keyColumnsAutoHint: "단일 테이블 비교 시 기본 키를 자동 감지하거나, 일괄 비교 시 테이블별로 자동 감지하려면 비워 두세요.",
|
||
rowCounts: "소스 {source}행, 대상 {target}행; 전체 비교 완료",
|
||
previewLimitOption: "미리보기 {count}",
|
||
compare: "데이터 비교",
|
||
recompare: "다시 비교",
|
||
summary: "추가 {added}, 제거 {removed}, 수정 {modified}",
|
||
batchSummary: "테이블 {tables}개 비교: {different}개 차이, {same}개 동일, {failed}개 실패; 추가 {added}, 제거 {removed}, 수정 {modified}",
|
||
comparingTable: "{current}/{total} 비교 중: {table}",
|
||
keyColumnsInline: "키 컬럼: {columns}",
|
||
selectedInline: "{selected}/{total} 선택됨",
|
||
selectedSummary: "선택: 추가 {added}, 제거 {removed}, 수정 {modified}",
|
||
selectAllKind: "모든 {kind} 선택",
|
||
clearKind: "{kind} 지우기",
|
||
clearSelection: "모든 선택 해제",
|
||
showAllRows: "전체 {count}개 표시",
|
||
showLessRows: "줄여서 보기",
|
||
remainingRows: "미리보기에서 {count}개 행이 추가로 숨겨져 있습니다",
|
||
planningSync: "동기화 계획 업데이트 중...",
|
||
noSelectedDifferences: "실행할 차이가 선택되지 않았습니다",
|
||
planSummary: "계획: 삽입 {inserts}, 수정 {updates}, 삭제 {deletes}, 구문 {statements}",
|
||
statusDifferent: "차이 있음",
|
||
statusSame: "동일",
|
||
statusError: "실패",
|
||
noKeyColumns: "최소 한 개의 키 컬럼을 선택하세요",
|
||
missingKeyColumns: "키 컬럼은 소스와 대상 테이블 모두에 존재해야 합니다: {columns}",
|
||
noCommonColumns: "소스와 대상 테이블에 비교할 공통 컬럼이 없습니다",
|
||
targetTableMissing: "대상 테이블을 찾을 수 없습니다: {table}",
|
||
noComparableTables: "비교 가능한 테이블이 없습니다. 같은 이름의 대상 테이블이 있는지 확인하세요.",
|
||
noDifferences: "데이터가 동일하여 동기화 SQL이 필요하지 않습니다",
|
||
syncSuccess: "데이터 동기화를 성공적으로 실행했습니다",
|
||
},
|
||
settings: {
|
||
title: "설정",
|
||
searchSettings: "설정 검색",
|
||
searchSettingsNoResults: "일치하는 설정이 없습니다",
|
||
searchSettingsResults: "설정 검색 결과",
|
||
clearSettingsSearch: "설정 검색 지우기",
|
||
exitSettingsSearch: "설정으로 돌아가기",
|
||
editorTab: "편집기",
|
||
showTableDdlHoverPreview: "호버 시 테이블 DDL 표시",
|
||
showTableDdlHoverPreviewDescription: "SQL 편집기에서 테이블 이름에 마우스를 올리면 DDL 미리 보기를 표시합니다.",
|
||
globalConnectTimeout: "전역 연결 제한 시간 (초)",
|
||
globalConnectTimeoutDescription: "전역 설정을 상속하는 연결에 사용됩니다.",
|
||
globalQueryTimeout: "전역 쿼리 제한 시간 (초)",
|
||
globalQueryTimeoutDescription: "전역 설정을 상속하는 연결에 사용됩니다. 0은 제한 시간 없음을 의미합니다.",
|
||
sqlFormatterTab: "SQL 포매터",
|
||
sqlFormatterImport: "설정 가져오기",
|
||
sqlFormatterExport: "설정 내보내기",
|
||
sqlFormatterImportSuccess: "포매터 설정을 가져왔습니다.",
|
||
sqlFormatterCopyJson: "JSON 복사",
|
||
sqlFormatterCopyJsonSuccess: "JSON을 복사했습니다.",
|
||
sqlFormatterCopyJsonFailed: "복사 실패: {message}",
|
||
sqlFormatterJsonEditorLoadFailed: "JSON 편집기를 불러오는 데 실패했습니다. 기본 입력으로 전환했습니다: {message}",
|
||
sqlFormatterRestoreDefaults: "기본값 복원",
|
||
sqlFormatterFormMode: "양식",
|
||
sqlFormatterJsonMode: "JSON",
|
||
sqlFormatterKeywordCase: "키워드 대소문자",
|
||
sqlFormatterFunctionCase: "함수 대소문자",
|
||
sqlFormatterDataTypeCase: "데이터 타입 대소문자",
|
||
sqlFormatterIdentifierCase: "식별자 대소문자",
|
||
sqlFormatterCaseUpper: "대문자",
|
||
sqlFormatterCaseLower: "소문자",
|
||
sqlFormatterCasePreserve: "유지",
|
||
sqlFormatterIndent: "들여쓰기",
|
||
sqlFormatterIndentSpaces: "공백",
|
||
sqlFormatterIndentTabs: "탭",
|
||
sqlFormatterTabWidth: "탭 너비",
|
||
sqlFormatterIndentStyle: "들여쓰기 스타일",
|
||
sqlFormatterIndentStyleStandard: "표준",
|
||
sqlFormatterIndentStyleTabularLeft: "표 왼쪽 정렬",
|
||
sqlFormatterIndentStyleTabularRight: "표 오른쪽 정렬",
|
||
sqlFormatterLogicalOperatorNewline: "논리 연산자 줄바꿈",
|
||
sqlFormatterLogicalBefore: "연산자 앞",
|
||
sqlFormatterLogicalAfter: "연산자 뒤",
|
||
sqlFormatterLogicalSameLine: "같은 줄 유지",
|
||
sqlFormatterFromClauseLayout: "FROM 절 레이아웃",
|
||
sqlFormatterFromNewLine: "다음 줄에 테이블 배치",
|
||
sqlFormatterFromSameLine: "FROM과 첫 번째 테이블을 같은 줄에 배치",
|
||
sqlFormatterExpressionWidth: "표현식 너비",
|
||
sqlFormatterLinesBetweenQueries: "쿼리 사이 줄 수",
|
||
sqlFormatterPreserveEmptyLines: "빈 줄 유지",
|
||
sqlFormatterDenseOperators: "조밀한 연산자",
|
||
sqlFormatterNewlineBeforeSemicolon: "세미콜론 새 줄에",
|
||
sqlFormatterAdvancedOptions: "고급 옵션",
|
||
sqlFormatterParams: "매개변수",
|
||
sqlFormatterParamTypes: "매개변수 유형",
|
||
sqlFormatterEditorShortcuts: "단축키",
|
||
sqlFormatterShortcutAction: "작업",
|
||
sqlFormatterShortcutEnabled: "활성화",
|
||
sqlFormatterShortcutWindows: "Windows",
|
||
sqlFormatterShortcutLinux: "Linux",
|
||
sqlFormatterShortcutMacos: "macOS",
|
||
sqlFormatterShortcutFind: "찾기",
|
||
sqlFormatterShortcutReplace: "바꾸기",
|
||
sqlFormatterShortcutIndentMore: "들여쓰기 늘리기",
|
||
sqlFormatterShortcutIndentLess: "들여쓰기 줄이기",
|
||
sqlFormatterShortcutDuplicateLine: "현재 줄 복제",
|
||
sqlFormatterShortcutDeleteLine: "현재 줄 삭제",
|
||
sqlFormatterShortcutMoveLine: "줄 이동",
|
||
sqlFormatterShortcutMoveLineUp: "줄 위로 이동",
|
||
sqlFormatterShortcutMoveLineDown: "줄 아래로 이동",
|
||
sqlFormatterShortcutCopyLine: "줄 복사",
|
||
sqlFormatterShortcutCopyLineUp: "줄 위로 복사",
|
||
sqlFormatterShortcutCopyLineDown: "줄 아래로 복사",
|
||
sqlFormatterShortcutUndo: "실행 취소",
|
||
sqlFormatterShortcutRedo: "다시 실행",
|
||
sqlFormatterShortcutSelectAll: "모두 선택",
|
||
sqlFormatterShortcutFormatJson: "JSON 서식",
|
||
sqlFormatterShortcutApply: "설정 적용",
|
||
sqlFormatterConfigErrorInvalidJson: "잘못된 JSON입니다.",
|
||
sqlFormatterConfigErrorObject: "설정은 JSON 객체여야 합니다.",
|
||
sqlFormatterConfigErrorVersion: "지원되지 않는 설정 버전입니다.",
|
||
sqlFormatterConfigErrorFormatter: "지원되지 않는 포매터입니다.",
|
||
sqlFormatterConfigErrorUnsupportedParams: "매개변수 교체 옵션이 지원되지 않습니다. SQL 서식은 자리표시자를 교체하지 않습니다.",
|
||
sqlFormatterConfigErrorOptionsObject: "설정 옵션은 JSON 객체여야 합니다.",
|
||
sqlFormatterConfigErrorEditorObject: "편집기 설정은 JSON 객체여야 합니다.",
|
||
sqlFormatterConfigErrorEditorScope: "지원되지 않는 편집기 범위입니다.",
|
||
sqlFormatterConfigErrorEditorPlatforms: "잘못된 편집기 플랫폼입니다.",
|
||
sqlFormatterConfigErrorEditorShortcutsArray: "편집기 단축키는 배열이어야 합니다.",
|
||
sqlFormatterConfigErrorEditorShortcutValue: "잘못된 편집기 단축키입니다.",
|
||
sqlFormatterConfigErrorUnknownOption: "알 수 없는 포매터 옵션: {option}.",
|
||
sqlFormatterConfigErrorInvalidOptionValue: "{option}의 값이 잘못되었습니다.",
|
||
sqlFormatterConfigErrorUnknownEditorShortcut: "알 수 없는 편집기 단축키: {shortcut}.",
|
||
sqlFormatterConfigErrorInvalidEditorShortcut: "잘못된 편집기 단축키: {shortcut}.",
|
||
sqlFormatterConfigErrorDuplicateEditorShortcut: "중복된 편집기 단축키: {shortcut}.",
|
||
sqlFormatterConfigErrorInvalidConfig: "잘못된 포매터 설정입니다.",
|
||
appearanceTab: "모양",
|
||
navigationTab: "탐색",
|
||
dataTab: "데이터",
|
||
sqlFileSection: "SQL 파일",
|
||
tunnelsTab: "터널",
|
||
tunnelsDescription: "재사용 가능한 SSH/프록시/HTTP 터널 설정입니다. 한 번 구성한 후 연결의 터널 탭에서 프로필을 선택하세요. 여기서의 편집은 이 프로필을 사용하는 모든 연결에 적용됩니다.",
|
||
tunnelsEmpty: "아직 터널 프로필이 없습니다. 여기서 만든 후 연결의 터널 설정에서 선택하세요.",
|
||
tunnelsAddSsh: "SSH 추가",
|
||
tunnelsAddProxy: "프록시 추가",
|
||
tunnelsAddHttp: "HTTP 터널 추가",
|
||
tunnelsProfileName: "프로필 이름",
|
||
tunnelsProfileNamePlaceholder: "예: 사무실 배스천",
|
||
tunnelsDelete: "삭제",
|
||
tunnelsUnnamedProfile: "이름 없는 프로필",
|
||
tunnelsSave: "저장",
|
||
tunnelsReset: "재설정",
|
||
tunnelsSaved: "터널 프로필을 저장했습니다",
|
||
tunnelsSaveFailed: "터널 프로필 저장에 실패했습니다: {message}",
|
||
tunnelsUnsavedHint: "저장되지 않은 변경 사항",
|
||
tunnelsTest: "테스트",
|
||
tunnelsTesting: "테스트 중...",
|
||
tunnelsTestSuccess: "터널 테스트 성공",
|
||
tunnelsTestFailed: "터널 테스트 실패: {message}",
|
||
tunnelsHttpTestSuccess: "HTTP CONNECT 프록시 연결 성공 ({code})",
|
||
tunnelsSocks5TestSuccess: "SOCKS5 프록시 연결 성공",
|
||
tunnelsProxyHostRequired: "프록시 호스트는 필수입니다.",
|
||
tunnelsProxyPortRequired: "프록시 포트는 필수입니다.",
|
||
tunnelsSshHostRequired: "SSH 호스트는 필수입니다.",
|
||
tunnelsHttpTunnelUnsupported: "HTTP 터널 프로필에 대해서는 터널 테스트가 지원되지 않습니다.",
|
||
tunnelsProxyTimedOut: "프록시 연결 시간 초과 ({duration})",
|
||
tunnelsProxyConnectFailed: "프록시 연결 실패: {error}",
|
||
tunnelsProxyHandshakeFailed: "프록시 핸드셰이크 실패: {error}",
|
||
tunnelsProxyHandshakeTimedOut: "프록시 핸드셰이크 시간 초과 ({duration})",
|
||
tunnelsHttpConnectFailed: "HTTP 프록시 CONNECT 실패: {detail}",
|
||
tunnelsSocksInvalidVersion: "잘못된 SOCKS 프록시 버전: {version}",
|
||
tunnelsSocksAuthTooLong: "SOCKS 사용자 이름 또는 비밀번호가 너무 깁니다",
|
||
tunnelsSocksAuthFailed: "SOCKS 프록시 인증 실패",
|
||
tunnelsSocksAuthRejected: "SOCKS 프록시가 지원되는 모든 인증 방법을 거부했습니다",
|
||
tunnelsSocksUnsupportedAuth: "SOCKS 프록시가 지원되지 않는 인증 방법을 선택했습니다: {method}",
|
||
tunnelsSocksHostTooLong: "프록시 호스트가 SOCKS5 도메인 주소에 비해 너무 깁니다",
|
||
tunnelsSocksConnectRejected: "SOCKS 프록시 연결 거부됨 (코드 {code})",
|
||
tunnelsSocksUnsupportedAddrType: "지원되지 않는 SOCKS 바운드 주소 유형: {type}",
|
||
redisTab: "Redis",
|
||
shortcutsTab: "단축키",
|
||
snippetsTab: "스니펫",
|
||
syncTab: "동기화",
|
||
aiTab: "AI",
|
||
mcpTab: "MCP",
|
||
jdbcTab: "JDBC 드라이버",
|
||
securityTab: "보안",
|
||
aboutTab: "정보",
|
||
fontFamily: "글꼴",
|
||
dataGridFontFamily: "결과 그리드 글꼴",
|
||
dataGridFontFamilyDescription: "쿼리 결과, 테이블 데이터, 컬럼 머리글 및 인라인 셀 편집기에 적용됩니다.",
|
||
uiFontFamily: "인터페이스 글꼴",
|
||
uiFontAppDefault: "DBX 기본",
|
||
uiFontSystemDefault: "시스템 기본",
|
||
uiFontFamilyDescription: "도구 모음, 탭, 사이드바, 대화상자 등 편집기가 아닌 UI에 적용됩니다.",
|
||
selectFont: "글꼴 선택...",
|
||
searchFont: "글꼴 검색...",
|
||
loadingFonts: "글꼴을 불러오는 중...",
|
||
noFontsFound: "글꼴이 없습니다",
|
||
useCustomFont: "“{font}” 사용",
|
||
languageTitle: "언어",
|
||
fontSize: "글꼴 크기",
|
||
toolbarTitle: "도구 모음",
|
||
toolbarHiddenHint: '숨겨지거나 넘친 일부 버튼은 "더보기" 드롭다운에 나타납니다.',
|
||
exclusiveRightSidebarPanels: "오른쪽 사이드바 패널 한 번에 하나만 표시",
|
||
exclusiveRightSidebarPanelsDescription: "오른쪽 사이드바 패널을 열면 다른 패널을 닫습니다. 여러 패널을 허용하려면 비활성화하세요.",
|
||
uiScale: "UI 배율",
|
||
uiScaleDescription: "고해상도 디스플레이를 위해 전체 데스크톱 UI를 확장합니다. 변경 사항은 즉시 적용되며 다음 실행 시 복원됩니다.",
|
||
theme: "테마",
|
||
cornerStyle: "모서리 스타일",
|
||
backgroundImage: "배경 이미지",
|
||
backgroundImageDescription: "앱 전체 배경에 이미지를 설정합니다. 카드와 대화상자는 가독성을 위해 불투명하게 유지됩니다.",
|
||
backgroundImageChoose: "이미지 선택…",
|
||
backgroundImageClear: "지우기",
|
||
backgroundImageNone: "이미지 없음",
|
||
backgroundImageTransparency: "투명도",
|
||
backgroundImageDisplayMode: "디스플레이 모드",
|
||
backgroundImageModeFill: "채우기",
|
||
backgroundImageModeFit: "맞춤",
|
||
backgroundImageModeStretch: "늘리기",
|
||
backgroundImageModeCenter: "가운데",
|
||
backgroundImageModeTile: "타일",
|
||
backgroundImageBlur: "흐림",
|
||
backgroundImageMissing: "이미지 파일이 더 이상 존재하지 않습니다. 다시 선택해 주세요.",
|
||
backgroundImageTooLarge: "이미지가 20MB 크기 제한을 초과합니다.",
|
||
backgroundImageSaveFailed: "배경 이미지를 저장하지 못했습니다.",
|
||
backgroundImageFilterName: "이미지",
|
||
cornerStyleNone: "각형",
|
||
cornerStyleSmall: "작게",
|
||
cornerStyleLarge: "크게",
|
||
selectTheme: "테마 선택...",
|
||
colorTheme: "색상 테마",
|
||
selectColorTheme: "색상 테마 선택...",
|
||
themePalettePearl: "화이트",
|
||
themePaletteMist: "미스트 그레이",
|
||
themePaletteGraphite: "티타늄 그레이",
|
||
themePaletteCobalt: "코발트 블루",
|
||
themePaletteSage: "세이지 그린",
|
||
themePaletteAmber: "웜 옐로우",
|
||
themePaletteBlush: "사쿠라 핑크",
|
||
themePaletteVscode: "VS Code",
|
||
themePaletteIdea: "IDEA",
|
||
themePaletteXcode: "Xcode",
|
||
themePaletteJetbrains: "JetBrains",
|
||
themePaletteCursor: "Cursor",
|
||
themePaletteClaude: "Claude Code",
|
||
followAppTheme: "앱 테마 따르기",
|
||
appLayout: "인터페이스 레이아웃",
|
||
appLayoutSeparated: "모던 분리형",
|
||
appLayoutSeparatedDescription: "블록 스타일 탭으로 패널을 명확하게 분리합니다.",
|
||
appLayoutClassic: "클래식 컴팩트",
|
||
appLayoutClassicDescription: "컴팩트한 패널 머리글의 연속 탭 바입니다.",
|
||
tabLayout: "탭 바 넘침",
|
||
tabLayoutScroll: "단일 행 스크롤",
|
||
tabLayoutScrollDescription: "탭이 넘칠 때 한 행에서 가로로 스크롤됩니다.",
|
||
tabLayoutWrap: "다중 행 줄바꿈",
|
||
tabLayoutWrapDescription: "탭이 여러 행으로 줄바꿈되어 모두 한 번에 표시됩니다.",
|
||
tabPlacement: "탭 표시줄 위치",
|
||
tabPlacementTop: "위쪽",
|
||
tabPlacementBottom: "아래쪽",
|
||
tabPlacementLeft: "왼쪽",
|
||
tabPlacementRight: "오른쪽",
|
||
tabPlacementDescription: "사이드 탭 표시줄은 세로로 스크롤됩니다. 여러 줄 표시는 콘텐츠 위 또는 아래에서만 적용됩니다.",
|
||
tabOrganization: "위치, 그룹화, 정렬",
|
||
tabGroup: "그룹 기준",
|
||
tabGroupNone: "그룹화 안 함",
|
||
tabGroupDatabaseType: "데이터베이스 유형별 그룹화",
|
||
tabGroupDatabase: "데이터베이스별 그룹화",
|
||
tabGroupConnection: "연결별 그룹화",
|
||
tabSort: "정렬 기준",
|
||
tabSortManual: "수동 순서",
|
||
tabSortCreated: "생성 시간",
|
||
tabSortTitle: "탭 이름",
|
||
tabOrganizationDescription: "그룹화와 정렬은 표시 순서에만 영향을 줍니다. 끌기는 수동 순서에서 사용할 수 있습니다.",
|
||
iconTheme: "아이콘 및 로고 스타일",
|
||
iconThemeDefault: "기본",
|
||
iconThemeDefaultDescription: "컬러 DBX 앱 아이콘을 사용합니다.",
|
||
iconThemeBlack: "검정",
|
||
iconThemeBlackDescription: "앱에서 검정 DBX 로고를 사용합니다.",
|
||
iconThemeBlackDescriptionMac: "앱에서 검정 로고를 사용합니다. Dock은 검정 판을 사용하고 메뉴 막대는 시스템을 따릅니다.",
|
||
showTrayIcon: "트레이/메뉴 막대 아이콘 표시",
|
||
showTrayIconDescription: "비활성화하면 아이콘이 표시되지 않지만, 창을 닫아도 이전처럼 DBX가 백그라운드에 숨겨집니다.",
|
||
quitOnClose: "창을 닫을 때 종료",
|
||
quitOnCloseDescription: "활성화하면 닫기 버튼을 클릭할 때 DBX가 트레이에 숨기지 않고 완전히 종료됩니다. 모양 설정에서 나중에 변경할 수 있습니다.",
|
||
closeActionPromptTitle: "창 닫기",
|
||
closeActionPromptDescription: "닫기 버튼을 클릭할 때 수행할 작업을 선택하세요. 설정 > 모양에서 나중에 변경할 수 있습니다.",
|
||
closeActionQuit: "DBX 종료",
|
||
closeActionMinimize: "트레이로 최소화",
|
||
updateNotificationsEnabled: "업데이트 알림 활성화",
|
||
updateNotificationsEnabledDescription: "앱과 드라이버 업데이트를 자동 확인하고 앱 업데이트를 조용히 다운로드합니다. 끄면 자동 확인, 앱 다운로드와 배지가 중지됩니다. 수동 확인 및 다운로드된 업데이트 설치는 가능합니다.",
|
||
updateDownloadSource: "업데이트 다운로드 소스",
|
||
updateDownloadSourceDescription: "앱 업데이트, 데이터베이스 에이전트, 드라이버, 관리 JRE를 다운로드할 위치를 선택하세요. 공식 소스를 권장합니다. 중국 본토 네트워크에서는 CNB가 더 빠를 수 있습니다.",
|
||
updateDownloadSourceOfficial: "공식 소스 (권장)",
|
||
updateDownloadSourceCnb: "CNB",
|
||
debugLoggingEnabled: "디버그 로그 활성화",
|
||
debugLoggingEnabledDescription: "문제 해결 보고서를 작성하는 동안 더 자세한 로컬 사용자 진단 로그를 기록합니다. 기본적으로 비활성화됩니다.",
|
||
duckDbWorkerProcessIsolation: "DuckDB 프로세스 격리 모드 (실험적)",
|
||
duckDbWorkerProcessIsolationDescription: "DuckDB 쿼리를 별도의 워커 프로세스에서 실행합니다. 긴 쿼리가 취소에 응답하지 않으면 DBX가 워커 프로세스를 중지하여 데이터베이스 파일 잠금을 해제할 수 있습니다.",
|
||
duckDbWorkerMaxProcesses: "DuckDB 최대 동시 워커",
|
||
duckDbWorkerMaxProcessesDescription: "DBX가 동시에 실행할 수 있는 DuckDB 워커 프로세스 수를 제한합니다. 범위: 1-16. 기본값: 4.",
|
||
duckDbWorkerProcessIsolationRestartRequired: "이 변경 사항을 적용하려면 DBX를 다시 시작하세요.",
|
||
restartDbx: "DBX 다시 시작",
|
||
restartDbxFailed: "DBX 다시 시작 실패: {error}",
|
||
applyFailed: "설정 적용 실패: {error}",
|
||
unsavedChangesCloseTitle: "저장하지 않은 변경 사항",
|
||
unsavedChangesCloseMessage: "저장하지 않은 설정 변경 사항이 있습니다. 지금 닫으면 사라집니다. 이 변경 사항을 취소하시겠습니까?",
|
||
unsavedChangesCloseCancel: "계속 편집",
|
||
unsavedChangesCloseDiscard: "변경 사항 취소",
|
||
debugLogsCopy: "로그 복사",
|
||
debugLogsCopied: "복사했습니다",
|
||
debugLogsDownload: "로그 다운로드",
|
||
debugLogsDownloaded: "다운로드했습니다",
|
||
debugLogsClear: "로그 지우기",
|
||
tableStructureSection: "테이블 구조",
|
||
dataGridDisplay: "데이터 그리드 표시",
|
||
dataGridFilterView: "테이블 필터 보기",
|
||
dataGridFilterViewDescription: "필터 팝오버, 고정 조건 패널 또는 간결한 텍스트 조건 패널을 사용합니다.",
|
||
dataGridFilterViewPreview: "효과 미리보기",
|
||
dataGridFilterViewPreviewExpand: "효과 미리보기 펼치기",
|
||
dataGridFilterViewPreviewCollapse: "효과 미리보기 접기",
|
||
tableOpenPageSize: "테이블을 열 때 기본 페이지당 행 수",
|
||
tableOpenPageSizeDescription: "새 테이블을 열 때 페이지당 로드되는 행 수입니다. 테이블에서 페이지당 행을 변경하면 향후 테이블 탭의 기본값이 업데이트됩니다.",
|
||
queryPageSize: "쿼리 결과 기본 페이지당 행 수",
|
||
queryPageSizeDescription: "쿼리 결과 페이지당 로드할 행 수입니다. 최대 {max}행을 지원합니다.",
|
||
defaultAutoKeepResults: "기본적으로 쿼리 결과 자동 보관",
|
||
defaultAutoKeepResultsDescription: "적용하면 열린 쿼리 탭을 업데이트하고 새 탭의 기본값으로 설정합니다. 탭별로 전환할 수 있습니다.",
|
||
multiStatementDefaultView: "여러 구문 기본 보기",
|
||
multiStatementDefaultViewDescription: "여러 SQL 구문이 있는 배치를 결과 테이블 또는 실행 요약 중 어디에서 열지 선택합니다.",
|
||
queryResultMaxRows: "쿼리 결과 최대 행 수",
|
||
queryResultMaxRowsEnabled: "쿼리 결과 행 수 제한",
|
||
queryResultMaxRowsDescription: "쿼리, 테이블 데이터, 저장 프로시저 및 연속 로딩에서 유지할 총 행 수를 제한합니다.",
|
||
queryResultMaxRowsTooSmall: "쿼리 페이지 크기({pageSize}) 이상이어야 합니다.",
|
||
externalSqlEditorMaxMb: "SQL 편집기 최대 파일 크기",
|
||
externalSqlEditorMaxMbDescription: "이 크기를 초과하는 SQL 파일은 편집기 대신 스트리밍 실행 대화상자로 전달됩니다({min}–{max} MB).",
|
||
webSqlFileUploadMaxMb: "웹 SQL 파일 최대 업로드 크기",
|
||
webSqlFileUploadMaxMbDescription: "웹 서버가 스트리밍 실행에 허용하는 가장 큰 SQL 파일({min}–{max} MB).",
|
||
sqlFileUploadMaxMbSaved: "웹 SQL 파일 업로드 크기가 저장되었습니다.",
|
||
showColumnCommentsInHeader: "이름 아래에 컬럼 주석 표시",
|
||
showColumnCommentsInHeaderDescription: "그리드 컬럼 이름 바로 아래에 테이블 컬럼 주석을 표시합니다.",
|
||
showColumnTypesInHeader: "이름 아래에 컬럼 타입 표시",
|
||
showColumnTypesInHeaderDescription: "그리드 컬럼 이름 바로 아래에 각 컬럼의 데이터 타입을 표시합니다.",
|
||
dataGridShowTransposeFieldMetadata: "전치 보기에 필드 메타데이터 표시",
|
||
dataGridShowTransposeFieldMetadataDescription: "활성화된 데이터 타입과 주석을 전치 보기의 별도 줄에 표시합니다. 활성화하면 행 높이가 증가합니다.",
|
||
colorizeDataGridCellTypes: "데이터 타입별 값 색상 표시",
|
||
colorizeDataGridCellTypesDescription: "테마에 맞는 은은한 텍스트 색상으로 컬럼 데이터 타입에 따라 값을 구분합니다.",
|
||
dataGridTypeColorScheme: "데이터 타입 색상 구성",
|
||
dataGridTypeColorSchemeDescription: "데이터 타입에 따라 값을 색으로 구분할 때 사용할 팔레트를 선택합니다.",
|
||
dataGridTypeColorSchemeConfigure: "사용자 지정",
|
||
dataGridTypeColorSchemeTitle: "데이터 타입 색상",
|
||
dataGridTypeColorSchemeAuto: "테마 따르기",
|
||
dataGridTypeColorSchemeAutoHint: "기본 색상을 사용하며 라이트와 다크 팔레트를 자동으로 전환합니다.",
|
||
dataGridTypeColorSchemeCreateFromCurrent: "현재 색상으로 구성 만들기",
|
||
dataGridTypeColorSchemeAdd: "새 구성",
|
||
dataGridTypeColorSchemeDuplicate: "구성 복제",
|
||
dataGridTypeColorSchemeRename: "구성 이름 바꾸기",
|
||
dataGridTypeColorSchemeRenameConfirm: "이름 바꾸기",
|
||
dataGridTypeColorSchemeDelete: "구성 삭제",
|
||
dataGridTypeColorSchemeReset: "색상 초기화",
|
||
dataGridTypeColorSchemeDone: "완료",
|
||
dataGridTypeColorSchemeDefaultName: "색상 구성",
|
||
dataGridTypeColorSchemeCopySuffix: " 복사본",
|
||
dataGridTypeColorInteger: "정수",
|
||
dataGridTypeColorNumeric: "소수",
|
||
dataGridTypeColorString: "텍스트",
|
||
dataGridTypeColorBoolean: "불리언",
|
||
dataGridTypeColorTemporal: "날짜/시간",
|
||
dataGridTypeColorStructured: "구조화",
|
||
dataGridTypeColorIdentifier: "식별자",
|
||
dataGridTypeColorBinary: "바이너리",
|
||
dataGridTypeColorSpatial: "공간",
|
||
showIndexIndicatorsInHeader: "컬럼 이름 옆에 인덱스 표시",
|
||
showIndexIndicatorsInHeaderDescription: "그리드 컬럼 헤더에 인덱스 유형을 아이콘으로 표시합니다: 기본키(주황색), 고유 인덱스(빨간색), 일반 인덱스(녹색).",
|
||
compactColumnHeaderActions: "컴팩트한 컬럼 머리글 도구",
|
||
compactColumnHeaderActionsDescription: "포매터와 로컬 필터 도구를 더보기 메뉴로 이동하여 컬럼 이름에 우선순위를 둡니다.",
|
||
dataGridQuickEntry: "빠른 그리드 입력",
|
||
dataGridQuickEntryDescription: "활성화하면 셀을 편집하거나 아래 빈 행을 채운 후 포커스가 벗어나는 즉시 데이터베이스에 저장합니다. 빈번한 입력에 유용하지만 실수로 쓰기를 유발할 수 있습니다.",
|
||
dataGridAutoTransposeSingleRow: "단일 행 쿼리 결과 자동 전치",
|
||
dataGridAutoTransposeSingleRowDescription: "활성화하면 정확히 한 행과 여러 열이 있는 SQL 쿼리 결과가 자동으로 전치 보기로 전환됩니다.",
|
||
dataGridCellDetailButtonVisible: "셀 세부 정보 버튼 표시",
|
||
dataGridCellDetailButtonVisibleDescription: "셀 위에 마우스를 올리면 셀 세부 정보 버튼을 표시합니다.",
|
||
dataGridCrosshairHighlight: "행·열 십자 강조",
|
||
dataGridCrosshairHighlightDescription: "활성화하면 활성 셀의 전체 행과 열을 연하게 강조합니다(Excel과 유사). 포커스 셀은 기존 선택 스타일을 유지합니다.",
|
||
infiniteScroll: "무한 스크롤 로딩",
|
||
autoCalculateTotalRows: "전체 행 수 자동 집계",
|
||
autoCalculateTotalRowsDescription: "각 쿼리 후 자동으로 COUNT(*)를 실행하여 일치하는 전체 행 수를 표시합니다. 대규모 쿼리를 빠르게 유지하기 위해 기본적으로 꺼져 있으며, 결과 푸터에서 요청 시 집계할 수 있습니다.",
|
||
infiniteScrollDescription: "목록 하단으로 스크롤할 때 다음 데이터 묶음을 자동으로 불러옵니다.",
|
||
dataGridShowWhitespace: "공백 문자 표시",
|
||
dataGridShowWhitespaceDescription: "데이터 셀의 공백을 ·, 탭을 →로 표시합니다. 복사하거나 편집하는 값은 변경되지 않습니다.",
|
||
flatteningMultiLineText: "멀티라인 텍스트 단순화",
|
||
flatteningMultiLineTextDescription: "다중 행 텍스트를 단일 행으로 병합하여 표시하고, 개행 문자는 ¶로 표시합니다.",
|
||
tableColumnTemplateFields: "새 테이블 미리 정의된 필드",
|
||
tableColumnTemplateFieldsDescription: "데이터베이스 유형을 선택한 다음 새 테이블을 만들 때 사용할 미리 정의된 필드 타입을 구성하세요.",
|
||
tableColumnTemplateAdd: "필드 추가",
|
||
tableColumnTemplateColumn: "필드",
|
||
tableColumnTemplateDatabase: "데이터베이스",
|
||
tableColumnTemplateType: "타입",
|
||
tableColumnTemplateLength: "길이",
|
||
tableColumnTemplateDefault: "기본값",
|
||
tableColumnTemplateNoPresetType: "미리 정의된 타입 없음",
|
||
tableColumnTemplateRequired: "필수",
|
||
tableColumnTemplateComment: "설명",
|
||
tableColumnTemplateDragHandle: "드래그하여 순서 변경",
|
||
sidebarActivation: "사이드바 활성화",
|
||
sidebarActivationSingle: "단일 클릭",
|
||
sidebarActivationSingleDescription: "한 번의 클릭으로 사이드바의 실행 가능한 항목을 엽니다.",
|
||
sidebarActivationDouble: "두 번 클릭",
|
||
sidebarActivationDoubleDescription: "단일 클릭은 행을 선택하고 두 번 클릭은 항목을 엽니다.",
|
||
sidebarObjectDisplay: "사이드바 객체 레이아웃",
|
||
sidebarObjectDisplayGrouped: "고급 보기",
|
||
sidebarObjectDisplayGroupedDescription: "객체 유형이 더 많은 데이터베이스의 경우 테이블, 뷰, 프로시저, 함수별로 객체를 그룹화합니다.",
|
||
sidebarObjectDisplaySimple: "단순 보기",
|
||
sidebarObjectDisplaySimpleDescription: "중간 수준을 줄이기 위해 각 데이터베이스나 스키마 아래에 테이블과 뷰를 직접 나열합니다.",
|
||
autoSelectActiveSidebarNode: "열린 항목 항상 선택",
|
||
autoSelectActiveSidebarNodeDescription: "탭을 전환할 때 사이드바에서 일치하는 표시된 테이블, 컬렉션 또는 SQL 파일을 선택합니다.",
|
||
sidebarBrowseObjectsOnDatabaseActivation: "데이터베이스 노드 활성화 시 객체 탐색",
|
||
sidebarBrowseObjectsOnDatabaseActivationDescription: '활성화하면 선택한 한 번 클릭 또는 두 번 클릭 방식으로 데이터베이스나 스키마 노드를 활성화할 때 사이드바를 펼치면서 "객체 탐색" 탭을 엽니다.',
|
||
openTabsRestoreMode: "실행 시 탭 복원",
|
||
openTabsRestoreModeDescription: "DBX가 지난번에 열려 있던 탭을 복원하는 방법을 선택하세요.",
|
||
openTabsRestoreModeAll: "모든 탭 유지",
|
||
openTabsRestoreModePinned: "고정 탭만 유지",
|
||
openTabsRestoreModeNone: "탭 유지 안 함",
|
||
openTabsRestoreModeHint: "고정 탭은 탭 바의 왼쪽에 유지되며 빈번한 진입점으로 잘 작동합니다.",
|
||
disconnectTabHandlingMode: "연결 해제 후 탭",
|
||
disconnectTabHandlingModeDescription: "연결이나 데이터베이스를 닫은 후 관련 탭을 처리하는 방법을 선택하세요.",
|
||
disconnectTabHandlingModeCloseTabs: "모든 탭 닫기",
|
||
disconnectTabHandlingModeCloseTabsDescription: "연결이나 데이터베이스의 모든 관련 탭을 닫습니다.",
|
||
disconnectTabHandlingModeKeepTabsClearResults: "객체 탭 닫기, SQL 탭 유지",
|
||
disconnectTabHandlingModeKeepTabsClearResultsDescription: "테이블 데이터, 객체 브라우저, 구조 탭을 닫고 SQL 쿼리 탭과 SQL 텍스트를 유지하며 실행 상태와 결과 세션도 지웁니다.",
|
||
disconnectTabHandlingModeKeepTabsKeepResults: "관련 탭 닫지 않기",
|
||
disconnectTabHandlingModeKeepTabsKeepResultsDescription: "관련 탭, SQL 텍스트, 현재 결과를 추가 정리 없이 유지합니다.",
|
||
reuseDataTab: "데이터 탭 재사용",
|
||
reuseDataTabDescription: "테이블을 열 때 데이터 탭을 사용하는 방식을 선택합니다.",
|
||
openDataTabsNextToActive: "새 데이터 탭을 활성 탭 옆에 열기",
|
||
openDataTabsNextToActiveDescription: "새로 만든 테이블 데이터 탭을 활성 탭 바로 뒤에 배치합니다.",
|
||
dataTabReuseAlwaysNew: "항상 새 탭 열기",
|
||
dataTabReuseAlwaysNewDescription: "테이블이 이미 열려 있어도 매번 새 데이터 탭을 만듭니다.",
|
||
dataTabReuseSameTable: "같은 테이블만 재사용",
|
||
dataTabReuseSameTableDescription: "같은 테이블은 기존 탭으로 전환하고 다른 테이블은 별도로 엽니다.",
|
||
dataTabReuseActiveTab: "활성 데이터 탭 재사용",
|
||
dataTabReuseActiveTabDescription: "안전한 경우 다른 테이블에 활성 데이터 탭을 재사용하며 보호된 탭은 별도로 엽니다.",
|
||
sidebarHiddenTablePrefixes: "숨겨진 테이블 이름 접두사",
|
||
sidebarHiddenTablePrefixesDescription: "한 줄에 하나의 접두사. 사이드바의 테이블, 뷰, 컬렉션 라벨만 줄이며 툴팁과 작업은 전체 이름을 계속 사용합니다.",
|
||
sidebarHiddenTablePrefixesPlaceholder: "예:\nODS_\nT8Y2_LONG_",
|
||
sidebarCopyTableNameSeparator: "테이블 이름 복사 구분자",
|
||
sidebarCopyTableNameSeparatorDescription: "사이드바에서 여러 테이블 또는 열 이름을 복사하거나 SQL 편집기로 끌어다 놓을 때 사용하는 구분자입니다.",
|
||
sidebarCopyTableNameIncludeSchema: "복사한 테이블 이름에 스키마 포함",
|
||
sidebarCopyTableNameIncludeSchemaDescription: "활성화하면 복사하거나 끌어다 놓은 테이블 이름이 활성 연결의 식별자 따옴표 규칙을 사용하는 스키마.테이블 형식이 됩니다.",
|
||
sidebarTablePageSize: "사이드바 페이지 크기",
|
||
sidebarTablePageSizeDescription: "사이드바 트리에서 페이지당 로드되는 최대 테이블/객체 수입니다. 테이블이 많고 페이지를 줄이려면 늘리세요.",
|
||
sidebarTableSearchEnabled: "데이터베이스 내 테이블 검색 활성화",
|
||
sidebarTableSearchEnabledDescription: "확장된 데이터베이스, 스키마 또는 테이블 그룹 아래에 로컬 테이블 검색 상자를 표시하여 각 범위가 독립적으로 테이블을 필터링할 수 있게 합니다.",
|
||
sidebarObjectInfoMode: "사이드바 추가 정보",
|
||
sidebarObjectInfoModeDescription: "이름 뒤에 주석, 객체 크기 또는 추가 텍스트 없음을 선택하세요. 주석과 크기는 상호 배타적입니다. 데이터베이스 합계는 현재 PostgreSQL을 지원하며, 테이블 크기는 MySQL, PostgreSQL, GaussDB, KingbaseES, GBase 8a, SQL Server, Oracle, Dameng, ClickHouse를 지원합니다.",
|
||
sidebarObjectInfoModeCommentInline: "주석 (이름 뒤)",
|
||
sidebarObjectInfoModeCommentAligned: "주석 (형제 정렬)",
|
||
sidebarObjectInfoModeCommentRight: "주석 (오른쪽 정렬)",
|
||
sidebarObjectInfoModeSize: "객체 크기",
|
||
sidebarObjectInfoModeHidden: "없음",
|
||
sidebarAllowHorizontalScroll: "사이드바 가로 스크롤 허용",
|
||
sidebarAllowHorizontalScrollDescription: "사이드바 가로 스크롤을 허용하여 긴 테이블, 뷰, 컬렉션 이름을 전체로 표시합니다.",
|
||
sidebarShowTooltips: "사이드바 호버 툴팁",
|
||
sidebarShowTooltipsDescription: "사이드바에서 연결 및 데이터베이스 개체에 마우스를 올리면 상세 툴팁을 표시합니다. 끄면 표시되지 않습니다.",
|
||
snippetsDescription: "편집기에서 트리거되는 SQL 스니펫 템플릿을 사용자 정의합니다.",
|
||
snippetsPlaceholderHint: "{'${번호:기본 텍스트}'}를 사용하여 편집 가능한 자리 표시자를 만듭니다. 같은 번호의 자리 표시자는 함께 수정됩니다. 예:",
|
||
snippetsAdd: "스니펫 추가",
|
||
snippetsLabel: "라벨",
|
||
snippetsPrefix: "접두사",
|
||
snippetsStatus: "상태",
|
||
snippetsEnabled: "활성화됨",
|
||
snippetsDisabled: "비활성화됨",
|
||
snippetsToggle: "스니펫 활성화 또는 비활성화",
|
||
snippetsBody: "SQL 본문",
|
||
snippetsLabelPlaceholder: "예: select *",
|
||
snippetsPrefixPlaceholder: "예: sel",
|
||
snippetsBodyPlaceholder: "SELECT *\nFROM table\nLIMIT 100;",
|
||
snippetsRestoreDefaults: "기본값 복원",
|
||
snippetsAddTitle: "스니펫 추가",
|
||
snippetsEditTitle: "스니펫 편집",
|
||
sqlShortcutsTitle: "SQL 빠른 작업",
|
||
sqlShortcutsDescription: "SQL 편집기에서 테이블 이름을 선택한 후 실행하는 사용자 지정 SQL 템플릿입니다. 먼저 테이블 식별자를 선택하세요. Cmd/Ctrl이 포함된 단축키를 권장합니다.",
|
||
sqlShortcutsAdd: "추가",
|
||
sqlShortcutsAddTitle: "SQL 빠른 작업 추가",
|
||
sqlShortcutsEditTitle: "SQL 빠른 작업 편집",
|
||
sqlShortcutsLabel: "라벨",
|
||
sqlShortcutsLabelPlaceholder: "예: 행 수 세기",
|
||
sqlShortcutsLabelRequired: "라벨은 필수입니다.",
|
||
sqlShortcutsSql: "SQL 템플릿",
|
||
sqlShortcutsSqlPlaceholder: "SELECT COUNT(*) FROM ${table}",
|
||
sqlShortcutsVariableHint: "선택한 테이블 이름에는 {token}을 사용하세요.",
|
||
sqlShortcutsEmpty: "아직 SQL 빠른 작업이 없습니다.",
|
||
sqlShortcutsUnbound: "미할당",
|
||
sqlShortcutsToggle: "SQL 단축키 활성화 또는 비활성화",
|
||
sqlShortcutsDeleteConfirm: 'SQL 단축키 "{name}"을(를) 삭제하시겠습니까?',
|
||
syncWebDavTitle: "WebDAV 동기화",
|
||
syncWebDavDescription: "WebDAV 호환 저장 서비스에서 DBX 스냅샷을 업로드하거나 복원합니다(저장된 SQL 라이브러리 항목 포함).",
|
||
syncWebDavWebDescription: "Web 모드에서는 DBX 서버가 WebDAV에 연결하므로 브라우저 CORS 제한을 받지 않습니다. 저장된 비밀번호는 현재 DBX 인스턴스에 유지됩니다.",
|
||
syncEndpoint: "WebDAV URL",
|
||
syncUsername: "사용자 이름",
|
||
syncPassword: "비밀번호",
|
||
syncPasswordPlaceholder: "비밀번호 입력",
|
||
syncClearSavedPassword: "저장된 비밀번호 지우기",
|
||
syncRememberWebDavPassword: "WebDAV 앱 비밀번호 기억",
|
||
syncSavedPassword: "(저장됨)",
|
||
syncRememberWebDavPasswordDescription: "비밀번호는 현재 DBX 인스턴스에만 암호화되어 저장됩니다. WebDAV에 동기화되지 않으며 동기화 비밀번호를 대체하지 않습니다.",
|
||
syncRemotePath: "원격 스냅샷 경로",
|
||
syncRemotePathDescription: "DBX가 업로드 시 누락된 상위 폴더를 만듭니다.",
|
||
syncSecretNotice: "기본적으로 DBX는 연결 세부 정보와 설정만 동기화합니다. 데이터베이스 비밀번호, SSH 비밀번호, 프록시 비밀번호, HTTP 터널 토큰, 연결 문자열 및 AI API 키는 로컬에 유지됩니다.",
|
||
syncSecrets: "암호화된 비밀 동기화",
|
||
syncSecretsDescription: "활성화하면 DBX가 데이터베이스 비밀번호, SSH 비밀번호, 프록시 비밀번호, HTTP 터널 토큰 및 AI API 키를 암호화하여 원격 저장소에 업로드합니다.",
|
||
syncSecretsSharedDescription: "WebDAV에서는 이 비밀번호로 포함할 자격 증명을 암호화합니다. GitHub Gist 및 Gitee 스니펫은 별도의 암호화 및 자격 증명 설정을 사용합니다.",
|
||
syncSecretsPassphrase: "동기화 비밀번호",
|
||
syncSecretsPassphraseDescription: "이 비밀번호는 민감한 데이터를 암호화하고 복원하는 데만 사용되며 현재 DBX 인스턴스에 암호화되어 저장됩니다. 다른 인스턴스에서는 다시 입력하세요.",
|
||
syncTest: "테스트",
|
||
syncUpload: "업로드",
|
||
syncDownload: "다운로드",
|
||
syncTestSuccess: "WebDAV 대상에 연결할 수 있습니다.",
|
||
syncUploadSuccess: "{path}에 {bytes}바이트를 업로드했습니다.",
|
||
syncAutoUpload: "자동으로 스냅샷 업로드",
|
||
syncAutoUploadInterval: "매",
|
||
syncAutoUploadMinutes: "분",
|
||
syncAutoUploadDescription: "DBX가 열려 있는 동안 실행됩니다. 로컬에 저장된 SQL이 예기치 않게 교체되는 것을 방지하기 위해 다운로드는 여전히 수동 확인이 필요합니다.",
|
||
syncAutoUploadSuccess: "{path}에 {bytes}바이트를 자동 업로드했습니다.",
|
||
syncDownloadSuccess: "{path}에서 {bytes}바이트를 다운로드하여 적용했습니다.",
|
||
syncSecretsApplied: "암호화된 비밀이 복원되었습니다.",
|
||
syncSecretsSkipped: "암호화된 비밀이 있었지만 복원되지 않았습니다.",
|
||
syncDownloadConfirm: "원격 DBX 스냅샷을 다운로드하여 적용하시겠습니까? 로컬 메타데이터와 저장된 SQL이 교체됩니다.",
|
||
syncSnippetTitle: "GitHub / Gitee 스니펫 동기화",
|
||
syncSnippetDescription: "동일한 DBX 스냅샷을 비공개 코드 스니펫에 저장합니다. 첫 업로드가 스니펫을 만들고 ID를 저장합니다.",
|
||
syncSnippetProvider: "공급자",
|
||
syncSnippetProviderGitee: "Gitee 스니펫",
|
||
syncSnippetId: "스니펫 ID",
|
||
syncSnippetIdPlaceholder: "첫 업로드의 경우 비워 두세요",
|
||
syncSnippetToken: "액세스 토큰",
|
||
syncSnippetRememberToken: "이 기기에 암호화하여 저장",
|
||
syncSnippetTokenDescription: "GitHub 토큰에는 Gists 쓰기 권한이 필요합니다. 토큰은 동기화 스냅샷에 절대 포함되지 않습니다.",
|
||
syncSnippetTestSuccess: "스니펫 동기화 대상에 접근할 수 있습니다.",
|
||
syncSnippetUploadSuccess: "스니펫 {id}에 {bytes}바이트를 업로드했습니다.",
|
||
syncSnippetDownloadSuccess: "스니펫 {id}에서 {bytes}바이트를 다운로드하여 적용했습니다.",
|
||
syncSnippetMigrateLegacy: "레거시 스니펫 마이그레이션",
|
||
syncSnippetMigrateLegacyRequired: "이 레거시 일반 텍스트 스니펫은 레거시 스니펫 마이그레이션 작업으로 이전해야 합니다.",
|
||
syncSnippetMigrateLegacyConfirm: "DBX는 먼저 암호화된 대체 스니펫을 만든 다음 레거시 일반 텍스트 스니펫 {id}를 영구 삭제합니다. 이 작업은 취소할 수 없습니다. 계속할까요?",
|
||
syncSnippetMigrateLegacySuccess: "암호화된 스니펫 {id}를 만들고 레거시 일반 텍스트 스니펫을 삭제했습니다.",
|
||
syncSnippetMigrateLegacyCreated: "암호화된 스니펫 {id}를 만들었습니다.",
|
||
syncSnippetMigrateLegacyCleanupRequired: "암호화된 스니펫은 만들었지만 레거시 스니펫 {id}를 삭제하지 못했습니다. 수동으로 삭제하고 노출되었을 수 있는 자격 증명을 교체하세요.",
|
||
syncSnippetRetryLegacyCleanup: "레거시 정리 다시 시도",
|
||
syncSnippetLegacyCleanupSuccess: "레거시 일반 텍스트 스니펫 {id}를 삭제했습니다.",
|
||
syncSnippetGuide: "설정 가이드",
|
||
apply: "적용",
|
||
applyAndClose: "적용 후 닫기",
|
||
reset: "재설정",
|
||
resetDefaults: "기본값 재설정",
|
||
resetAllDefaults: "모든 기본값 재설정",
|
||
save: "저장",
|
||
cancel: "취소",
|
||
executeMode: "실행 모드",
|
||
executeModeDescription: "SQL 실행 단축키: {shortcut}. 기본적으로 전체 SQL 또는 커서가 있는 구문 중 무엇을 실행할지 설정합니다.",
|
||
executeModeAll: "모든 SQL 실행",
|
||
executeModeCurrent: "커서 위치의 구문 실행",
|
||
defaultTransactionMode: "기본 트랜잭션 커밋 모드",
|
||
defaultTransactionModeDescription:
|
||
'새 SQL 편집기를 열 때 기본적으로 사용되는 트랜잭션 모드입니다. "수동 트랜잭션"을 선택하면 새 편집기가 수동 트랜잭션 모드로 시작되어 수동으로 커밋 또는 롤백해야 합니다. "자동 커밋"을 선택하면 각 문이 자동으로 커밋됩니다. 트랜잭션을 지원하는 데이터베이스(PostgreSQL, MySQL, Oracle, JDBC)에만 적용됩니다.',
|
||
defaultTransactionModeAuto: "자동 커밋",
|
||
defaultTransactionModeManual: "수동 트랜잭션",
|
||
executeAllOnBlankLine: "빈 줄에서 모든 SQL 실행",
|
||
executeAllOnBlankLineDescription: "현재 구문 실행 모드에서 커서 위치에 구문이 없으면 모든 SQL을 실행합니다. 기본적으로 비활성화됩니다.",
|
||
showExecutionTargetPicker: "실행 대상 선택기 표시",
|
||
showExecutionTargetPickerDescription: "활성화하면 선택 없이 실행할 때 현재 구문과 전체 SQL 중에서 선택할 수 있습니다.",
|
||
showStatementRunButtons: "왼쪽 실행 버튼 표시",
|
||
showStatementRunButtonsDescription: "SQL 편집기 여백에 구문별 실행 버튼을 표시합니다. 비활성화해도 키보드 단축키와 컨텍스트 메뉴 실행은 계속 작동합니다.",
|
||
showLineNumbers: "줄 번호 표시",
|
||
showLineNumbersDescription: "SQL 편집기 여백에 줄 번호를 표시합니다",
|
||
showCurrentStatementFrame: "현재 구문 프레임 표시",
|
||
showCurrentStatementFrameDescription: "활성화하면 SQL 편집기가 현재 실행 가능한 구문 주위에 윤곽선을 그립니다. 비활성화하면 윤곽선이 숨겨집니다.",
|
||
showInsertValueHints: "INSERT 값 컬럼 힌트 표시",
|
||
showInsertValueHintsDescription: "활성화하면 SQL 편집기가 INSERT ... VALUES 또는 INSERT ... SELECT 절의 각 값/프로젝션 옆에 컬럼 이름 힌트를 표시합니다.",
|
||
previewStatementRunButton: "구문 실행 버튼 미리보기",
|
||
wordWrap: "자동 줄바꿈",
|
||
wordWrapDescription: "편집기 너비 내에서 긴 줄을 줄바꿈합니다",
|
||
vimMode: "Vim 모드",
|
||
vimModeDescription: "SQL 편집기에서 Vim 스타일의 모달 편집을 사용합니다",
|
||
autoCloseBrackets: "괄호 자동 닫기",
|
||
autoCloseBracketsDescription: "여는 괄호나 따옴표를 입력할 때 닫는 괄호와 따옴표를 자동으로 삽입합니다",
|
||
sqlCompletionSection: "SQL 자동 완성",
|
||
insertSpaceAfterCompletion: "완성 후 공백 삽입",
|
||
insertSpaceAfterCompletionDescription: "다음 문자가 허용할 때 키워드, 테이블 또는 컬럼 완성을 수락한 후 공백을 추가합니다",
|
||
selectFirstCompletionOnOpen: "첫 번째 자동 완성 후보 자동 선택",
|
||
selectFirstCompletionOnOpenDescription: "활성화하면 후보 목록이 열릴 때 첫 항목을 선택하고 Enter 또는 Tab으로 적용합니다. 비활성화하면 Enter는 줄을 바꾸고 Tab은 첫 후보를 적용합니다.",
|
||
completionTriggerMode: "SQL 자동 완성 트리거 모드",
|
||
completionTriggerModeDescription: "SQL 자동 완성 후보 표시 방식을 선택합니다.",
|
||
completionTriggerModeManual: "수동만",
|
||
completionTriggerModeManualDescription: "자동 완성 단축키 {shortcut}을 사용할 때만 후보를 표시합니다.",
|
||
completionTriggerModeRequirePrefix: "식별자 입력 후",
|
||
completionTriggerModeRequirePrefixDescription: "식별자 문자를 하나 이상 입력하면 후보를 표시합니다.",
|
||
completionTriggerModePositional: "스마트 위치",
|
||
completionTriggerModePositionalDescription: "현재 SQL 구문 위치에 따라 후보를 자동으로 표시합니다.",
|
||
sqlSemanticDiagnosticsEnabled: "SQL 의미 진단",
|
||
sqlSemanticDiagnosticsEnabledDescription: "활성화하면 편집기가 알 수 없는 테이블과 컬럼 같은 의미 문제를 보고합니다. 대규모 SQL의 파싱과 메타데이터 검사를 줄이려면 비활성화하세요.",
|
||
confirmDangerousSqlExecution: "위험한 작업 전에 확인",
|
||
confirmDangerousSqlExecutionDescription: "비활성화하면 위험한 SQL과 테이블 행 또는 문서 삭제가 경고 대화상자 없이 실행됩니다.",
|
||
continueOnErrorOnBatch: "오류 시 계속",
|
||
continueOnErrorOnBatchDescription: "활성화하면 다중 구문 실행이 첫 번째 실패에서 중지하는 대신 오류 후에도 계속됩니다.",
|
||
confirmUnsavedSqlClose: "저장되지 않은 SQL 닫기 전 확인",
|
||
confirmUnsavedSqlCloseDescription: "비활성화하면 저장되지 않은 편집이 있는 SQL 탭이 저장 확인 대화상자 없이 닫히거나 종료됩니다.",
|
||
appCloseUnsavedTabsMode: "종료 시 저장되지 않은 SQL",
|
||
appCloseUnsavedTabsModeDescription: "저장되지 않은 편집이 있는 SQL 탭을 열어 둔 채 DBX를 종료할 때 동작을 선택합니다.",
|
||
appCloseUnsavedTabsModePrompt: "저장 여부 묻기",
|
||
appCloseUnsavedTabsModeKeepDrafts: "묻지 않고 종료 후 초안 유지",
|
||
appCloseUnsavedTabsModeHint: '초안은 저장되지 않은 탭으로 유지되며 다음에 DBX를 시작할 때 복원됩니다. "실행 시 탭 복원"이 "탭 유지 안 함"으로 설정되어 있지 않아야 합니다.',
|
||
appCloseDraftPersistFailed: "열린 탭의 초안을 저장하지 못해 DBX 종료를 취소했습니다. 디스크 공간과 파일 권한을 확인한 후 다시 종료하세요. 세부 정보: {message}",
|
||
savedSqlOpenTarget: "저장된 SQL의 기본 실행 대상",
|
||
savedSqlOpenTargetSaved: "저장된 대상",
|
||
savedSqlOpenTargetSavedDescription: "SQL 파일에 저장된 연결, 데이터베이스 및 스키마를 사용합니다.",
|
||
savedSqlOpenTargetCurrent: "현재 탭",
|
||
savedSqlOpenTargetCurrentDescription: "가능한 경우 현재 탭의 연결, 데이터베이스, 스키마 및 카탈로그를 사용하고, 그렇지 않으면 저장된 대상을 사용합니다.",
|
||
prefillNewQueryWithSelect: "새 쿼리에 SELECT * 미리 채우기",
|
||
prefillNewQueryWithSelectDescription: "새 쿼리를 만들 때 활성 테이블 탭이나 사이드바에서 선택한 테이블을 기반으로 편집기에 SELECT * FROM <table>을 미리 채웁니다.",
|
||
generateSqlIncludeDatabaseName: "생성된 SQL에 데이터베이스 이름 포함",
|
||
generateSqlIncludeDatabaseNameDescription: "데이터베이스가 지원하는 경우 생성된 테이블 SQL에서 테이블 이름만이 아니라 database.table을 사용합니다.",
|
||
generateSqlQuoteIdentifiers: "생성된 SQL에서 식별자 인용",
|
||
generateSqlQuoteIdentifiersDescription: "끄면 새 쿼리의 테이블 참조에서 데이터베이스 방언별 인용을 생략합니다. 예약어, 특수 문자 또는 대소문자 구분 이름에는 인용이 필요할 수 있습니다.",
|
||
formatSqlOnSqlFileSave: "SQL 파일 저장 시 SQL 서식 지정",
|
||
formatSqlOnSqlFileSaveDescription: "SQL 파일을 저장할 때 SQL을 자동으로 서식 지정합니다. SQL 라이브러리에 저장된 파일과 새 쿼리를 .sql 파일로 저장하는 경우도 포함합니다.",
|
||
sqlVariableSyntax: "SQL 변수 및 자리표시자 치환",
|
||
sqlVariableSyntaxDescription: "데이터베이스 유형별로 SQL을 실행하기 전에 DBX가 치환할 변수와 자리표시자 문법을 선택하세요. 모두 기본적으로 활성화됩니다.",
|
||
sqlVariableSubstitutionEnabled: "치환 사용",
|
||
sqlVariableSyntax_positional: "위치 자리표시자",
|
||
sqlVariableSyntax_positionalDescription: "각 위치 자리표시자를 순서대로 치환할 값을 입력하라는 메시지를 표시합니다.",
|
||
sqlVariableSyntax_named: "이름 있는 자리표시자",
|
||
sqlVariableSyntax_namedDescription: "이름 있는 자리표시자를 치환할 값을 입력하라는 메시지를 표시합니다.",
|
||
sqlVariableSyntax_shell: "셸 스타일 자리표시자",
|
||
sqlVariableSyntax_shellDescription: "셸 스타일 자리표시자를 치환할 값을 입력하라는 메시지를 표시합니다.",
|
||
sqlVariableSyntax_mybatis: "MyBatis 스타일 자리표시자",
|
||
sqlVariableSyntax_mybatisDescription: "MyBatis 스타일 자리표시자를 치환할 값을 입력하라는 메시지를 표시합니다.",
|
||
sqlVariableSyntax_sqlserver: "SQL Server 스타일 자리표시자",
|
||
sqlVariableSyntax_sqlserverDescription: "SQL Server 스타일 자리표시자를 치환할 값을 입력하라는 메시지를 표시합니다 (세션 변수와 충돌할 수 있음).",
|
||
sqlVariableSyntax_atSet: "인라인 변수 확장",
|
||
sqlVariableSyntax_atSetDescription: "실행 전에 인라인 변수 선언을 확장하고 값을 치환합니다.",
|
||
autoAliasTables: "자동으로 테이블 별칭 추가",
|
||
autoAliasTablesDescription: "FROM이나 JOIN에서 테이블 완성을 선택할 때 order_items AS oi 같은 생성된 별칭을 삽입합니다.",
|
||
redisKeyTemplatesSection: "Redis",
|
||
redisKeyTemplates: "키 검색 템플릿",
|
||
redisKeyTemplatesPlaceholder: "Example:\nuser:{'{'}$userId{'}'}\nv3:adui:{'{'}$positionID{'}'}",
|
||
redisKeyTemplatesDescription: "한 줄에 하나의 템플릿. 연결에 템플릿이 없을 때 전역 폴백으로 사용됩니다.",
|
||
redisScanPageSize: "Redis 스캔 개수",
|
||
redisScanPageSizeDescription: "키를 탐색할 때 Redis SCAN 페이지당 요청하는 키 수입니다.",
|
||
redisScanPageSizeOption: "키 {count}개",
|
||
exportBatchSize: "내보내기 배치 크기",
|
||
dateTimeSection: "날짜 및 시간",
|
||
globalDateTimeDisplayFormat: "전역 표시 형식",
|
||
globalDateTimeDisplayFormatDescription: "컬럼별 포매터가 없는 시간 컬럼에 모든 데이터베이스에서 적용됩니다.",
|
||
globalDateTimeExportFormat: "전역 내보내기 형식",
|
||
globalDateTimeExportFormatDescription: "CSV, Excel, JSON, Markdown 및 텍스트 내보내기에서 시간 컬럼을 일관되게 서식합니다.",
|
||
globalDateTimeImportFormat: "전역 가져오기 형식",
|
||
globalDateTimeImportFormatDescription: "가져온 시간 값을 이 형식으로 파싱합니다. 자동 감지하려면 비워 두세요.",
|
||
dateTimeFormatRaw: "데이터베이스 값 유지",
|
||
dateTimeFormatAuto: "자동 감지",
|
||
dateTimeFormatSearchPlaceholder: "형식 선택 또는 입력",
|
||
dateTimeFormatEmpty: "사용자 지정 날짜/시간 형식 입력",
|
||
exportBatchSizeDescription: "데이터를 내보낼 때 배치당 가져오는 행 수 (100-100000).",
|
||
exportRowLimitEnabled: "내보내는 행 제한",
|
||
exportRowLimitEnabledDescription: "활성화하면 쿼리 결과와 테이블 데이터 내보내기가 아래 행 제한에서 중지됩니다.",
|
||
exportRowLimit: "데이터 내보내기 행 제한",
|
||
exportRowLimitDescription: "쿼리 결과와 테이블 데이터 내보내기의 최대 행 수입니다.",
|
||
exportRowLimitUnlimited: "제한 없음",
|
||
queryExportKeysetOptimizationEnabled: "키셋 최적화 시도",
|
||
queryExportKeysetOptimizationEnabledDescription: "안전하게 인식된 단일 테이블 쿼리에만 적용되며 복잡한 쿼리는 자동으로 폴백됩니다.",
|
||
exportSection: "내보내기",
|
||
performanceSection: "성능",
|
||
shortcutExecuteSql: "SQL 실행",
|
||
shortcutExecuteSqlInNewResultTab: "새 결과 탭에서 SQL 실행",
|
||
shortcutFind: "찾기",
|
||
shortcutReplace: "바꾸기",
|
||
shortcutSaveSql: "SQL 저장",
|
||
shortcutAcceptCompletion: "완성 수락",
|
||
shortcutTriggerCompletion: "완성 트리거",
|
||
shortcutFormatSql: "SQL 서식",
|
||
shortcutExpandSelectStar: "*을(를) 열로 확장",
|
||
shortcutToggleLineComment: "줄 주석 전환",
|
||
shortcutToggleBlockComment: "블록 주석 전환",
|
||
shortcutIndentMore: "들여쓰기 늘리기",
|
||
shortcutIndentLess: "들여쓰기 줄이기",
|
||
shortcutInsertLineBelow: "아래에 줄 삽입",
|
||
shortcutJoinLines: "줄 합치기",
|
||
shortcutDuplicateLine: "현재 줄 복제",
|
||
shortcutDeleteLine: "현재 줄 삭제",
|
||
shortcutMoveLineUp: "줄 위로 이동",
|
||
shortcutMoveLineDown: "줄 아래로 이동",
|
||
shortcutCopyLineUp: "줄 위로 복사",
|
||
shortcutCopyLineDown: "줄 아래로 복사",
|
||
shortcutUndo: "실행 취소",
|
||
shortcutRedo: "다시 실행",
|
||
shortcutSelectAll: "모두 선택",
|
||
shortcutAddNextSelectionOccurrence: "다음 일치 항목 선택 추가",
|
||
shortcutSelectAllSelectionOccurrences: "모든 일치 항목 선택",
|
||
shortcutEditTableStructure: "테이블 구조 편집",
|
||
shortcutCopyCurrentRow: "현재 데이터 행 복사",
|
||
shortcutDeleteCurrentRow: "현재 데이터 행 삭제",
|
||
shortcutGoToColumn: "컬럼으로 이동",
|
||
shortcutGoToFirstPage: "첫 페이지",
|
||
shortcutGoToPreviousPage: "이전 페이지",
|
||
shortcutGoToNextPage: "다음 페이지",
|
||
shortcutGoToLastPage: "마지막 페이지",
|
||
shortcutNewQuery: "새 쿼리",
|
||
shortcutOpenSettings: "설정 열기",
|
||
shortcutCloseTab: "탭 닫기",
|
||
shortcutFocusSearch: "현재 화면 검색에 포커스",
|
||
shortcutQuickOpen: "빠른 열기 (모든 데이터베이스 객체 검색)",
|
||
shortcutNavigateTabHistoryBack: "이전에 본 탭으로 돌아가기",
|
||
shortcutTabSwitcher: "탭 전환기 (길게 눌러 표시, 놓으면 전환)",
|
||
shortcutNavigateTabHistoryForward: "다음에 본 탭으로 이동",
|
||
shortcutSwitchToPreviousTab: "이전 탭으로 전환",
|
||
shortcutSwitchToNextTab: "다음 탭으로 전환",
|
||
shortcutSwitchToTab1: "탭 1로 전환",
|
||
shortcutSwitchToTab2: "탭 2로 전환",
|
||
shortcutSwitchToTab3: "탭 3로 전환",
|
||
shortcutSwitchToTab4: "탭 4로 전환",
|
||
shortcutSwitchToTab5: "탭 5로 전환",
|
||
shortcutSwitchToTab6: "탭 6로 전환",
|
||
shortcutSwitchToTab7: "탭 7로 전환",
|
||
shortcutSwitchToTab8: "탭 8로 전환",
|
||
shortcutSwitchToTab9: "탭 9로 전환",
|
||
shortcutZoomInUi: "UI 확대",
|
||
shortcutZoomOutUi: "UI 축소",
|
||
shortcutResetUiZoom: "UI 확대/축소 재설정",
|
||
shortcutRefreshData: "데이터 새로고침",
|
||
shortcutToggleResultsPane: "결과 창 전환",
|
||
shortcutToggleTranspose: "전치 보기 전환",
|
||
shortcutCancelSearch: "검색 취소",
|
||
shortcutToggleSidebar: "사이드바 전환",
|
||
shortcutToggleZenMode: "Zen 모드 전환",
|
||
shortcutCopySidebarSelection: "사이드바 선택 복사",
|
||
shortcutPasteSidebarSelection: "사이드바에 붙여넣기",
|
||
shortcutEditSidebarConnection: "사이드바 연결 편집",
|
||
shortcutOpenDataInNewTab: "새 탭에서 데이터 열기 (마우스 클릭)",
|
||
shortcutViewTableDdl: "테이블 DDL 보기",
|
||
shortcutSendSelectionToAi: "선택 영역을 AI로 보내기",
|
||
shortcutToggleAiPanel: "AI 패널 전환",
|
||
shortcutSqlIntentionActions: "SQL 인텐트 동작 (* 펼치기 / 식별자 한정)",
|
||
intentionExpandWildcard: "* 을(를) 열 목록으로 펼치기",
|
||
intentionQualifyIdentifier: "식별자 한정",
|
||
intentionUnqualifyIdentifier: "한정 해제",
|
||
intentionBatchQualifyIdentifiers: "식별자 일괄 한정",
|
||
shortcutScopeGlobal: "전역",
|
||
shortcutScopeEditor: "SQL 편집기",
|
||
shortcutScopeGrid: "데이터 그리드",
|
||
shortcutScopeSearch: "필드 검색",
|
||
shortcutScopeSidebar: "사이드바",
|
||
shortcutPressShortcut: "단축키를 누르세요",
|
||
shortcutSearchPlaceholder: "단축키 검색",
|
||
shortcutSearchNoResults: "검색과 일치하는 단축키가 없습니다.",
|
||
shortcutConflict: "이 단축키는 같은 범위의 다른 작업과 충돌합니다.",
|
||
shortcutReserved: "이 단축키는 시스템에서 예약되었습니다.",
|
||
shortcutClear: "단축키 지우기",
|
||
preview: "실시간 미리보기",
|
||
previewSyntaxErrorHint: "미리보기는 읽기 전용입니다. 데모 SQL의 FOM 오타는 의도적인 구문 오류이며 오류 강조 표시를 보여줍니다.",
|
||
customTheme: "사용자 지정 테마",
|
||
customThemeConfigure: "사용자 지정 테마 설정",
|
||
customThemeTitle: "사용자 지정 테마 구성",
|
||
customThemeMyThemes: "내 테마",
|
||
customThemeNewTheme: "새 테마",
|
||
customThemeVisualEdit: "시각적 편집기",
|
||
customThemeJsonConfig: "JSON 설정",
|
||
customThemeLivePreview: "실시간 미리보기",
|
||
customThemePreviewExample: "-- 쿼리 예시",
|
||
customThemePreset: "프리셋 테마",
|
||
customThemeSelectPreset: "프리셋 테마 선택...",
|
||
customThemeApply: "적용",
|
||
customThemePasteImport: "붙여넣어 가져오기",
|
||
customThemeExportJson: "JSON 내보내기",
|
||
customThemeSaveAndApply: "저장 후 적용",
|
||
customThemeKeyword: "키워드",
|
||
customThemeField: "필드/변수",
|
||
customThemeFunction: "함수",
|
||
customThemeString: "문자열",
|
||
customThemeNumber: "숫자",
|
||
customThemeComment: "주석",
|
||
customThemeTable: "테이블",
|
||
customThemeOperator: "연산자",
|
||
customThemeType: "타입",
|
||
customThemeBuiltin: "내장",
|
||
customThemeBackground: "배경",
|
||
customThemeForeground: "전경",
|
||
customThemeDefaultName: "사용자 지정 테마",
|
||
customThemeCopySuffix: " 사본",
|
||
customThemeApplied: '"{name}" 색 구성표를 적용했습니다',
|
||
customThemeKeepOne: "최소 한 개의 테마를 유지하세요",
|
||
customThemeJsonError: "잘못된 JSON 형식, 확인해 주세요",
|
||
jdbcPlugin: "DBX JDBC 플러그인",
|
||
jdbcPluginInstall: "JDBC 플러그인 설치",
|
||
jdbcPluginInstallSuccess: "JDBC 플러그인을 설치했습니다",
|
||
jdbcPluginUpdate: "업데이트",
|
||
jdbcPluginUninstall: "제거",
|
||
jdbcPluginUninstallSuccess: "JDBC 플러그인을 제거했습니다",
|
||
jdbcPluginInstalled: "설치됨: v{version}",
|
||
jdbcPluginIncompatible: "호환되지 않는 프로토콜",
|
||
jdbcPluginNotInstalled: "설치되지 않음",
|
||
jdbcDrivers: "JDBC 드라이버 JAR",
|
||
jdbcImport: "JAR 가져오기",
|
||
jdbcImportPath: "가져오기 경로",
|
||
jdbcDriverPathPlaceholder: "/path/to/driver.jar",
|
||
jdbcImportSuccess: "드라이버 파일 {count}개를 가져왔습니다",
|
||
jdbcDeleteSuccess: "드라이버를 제거했습니다",
|
||
jdbcNoDrivers: "아직 가져온 JDBC 드라이버가 없습니다.",
|
||
mcpTitle: "MCP 서버",
|
||
mcpDescription: "Claude Code, Cursor 및 기타 에이전트가 사용하는 DBX MCP 서버 설치와 버전을 확인합니다.",
|
||
mcpChecking: "확인 중",
|
||
mcpStatusUnknown: "확인하지 않음",
|
||
mcpStatusError: "확인 실패",
|
||
mcpReady: "준비됨",
|
||
mcpNotInstalled: "설치되지 않음",
|
||
mcpUpdateAvailable: "업데이트 가능",
|
||
mcpCurrent: "현재 버전",
|
||
mcpLatest: "최신 버전",
|
||
mcpVersionMissing: "감지된 전역 설치 없음",
|
||
mcpVersionUnknown: "알 수 없음",
|
||
mcpAvailable: "사용 가능",
|
||
mcpUnavailable: "사용 불가",
|
||
mcpBinPath: "명령 경로",
|
||
mcpInstallCommand: "설치 명령",
|
||
mcpUpdateCommand: "업그레이드 명령",
|
||
mcpInstallButton: "설치",
|
||
mcpUpdateButton: "업그레이드",
|
||
mcpUpToDate: "최신 상태",
|
||
mcpInstalling: "설치 중...",
|
||
mcpInstallSuccess: "설치 성공",
|
||
mcpInstallFailed: "설치 실패",
|
||
mcpConfig: "MCP 설정",
|
||
mcpConfigOptionsHint: "DBX가 모든 MCP 클라이언트에 대해 연결 접근과 실행 권한을 중앙에서 제어합니다. 생성된 설정에는 MCP 서버를 시작하고 이 DBX 인스턴스에 연결하는 데 필요한 런타임 설정만 포함되며, 권한이나 연결 범위 변수는 없습니다.",
|
||
mcpScopeConnection: "MCP에 허용된 연결",
|
||
mcpScopeConnectionDescription: "DBX는 선택한 연결만 MCP에 노출합니다. 변경 사항은 모든 MCP 클라이언트에 적용됩니다.",
|
||
mcpScopeMode: "연결 범위 모드",
|
||
mcpScopeModeAll: "모든 연결",
|
||
mcpScopeModeAllDescription: "향후 연결을 자동으로 포함합니다",
|
||
mcpScopeModeSelected: "특정 연결",
|
||
mcpScopeModeSelectedDescription: "명시적으로 추가된 연결만",
|
||
mcpScopeAllowedPane: "허용됨",
|
||
mcpScopeAvailablePane: "사용 가능",
|
||
mcpScopeAddAll: "모두 추가",
|
||
mcpScopeRemoveAll: "모두 제거",
|
||
mcpScopeAddMatches: "일치 항목 추가 ({count})",
|
||
mcpScopeRemoveMatches: "일치 항목 제거 ({count})",
|
||
mcpScopeAddConnection: "{name}에 MCP 접근 허용",
|
||
mcpScopeRemoveConnection: "{name}의 MCP 접근 제거",
|
||
mcpScopeAvailableEmpty: "추가할 수 있는 연결이 없습니다",
|
||
mcpScopeAllowedEmpty: "현재 허용된 연결이 없습니다",
|
||
mcpScopeUnavailableGroup: "사용 불가능한 연결 ({count})",
|
||
mcpScopeRemoveUnavailableConnection: "허용 목록에서 사용 불가능한 연결 {id} 제거",
|
||
mcpScopeUpdatedAnnouncement: "MCP가 현재 사용 가능한 {total}개 연결 중 {selected}개를 허용합니다",
|
||
mcpConnectionSearchPlaceholder: "이름, 유형, 주소, 데이터베이스 또는 연결 ID 검색",
|
||
mcpConnectionSearchEmpty: "일치하는 연결이 없습니다",
|
||
mcpConnectionListEmpty: "사용 가능한 연결이 없습니다",
|
||
mcpScopeAllAction: "모두 허용",
|
||
mcpScopeNoneAction: "모두 지우기",
|
||
mcpScopeAllSummary: "모든 연결 {count}개",
|
||
mcpScopeSelectedSummary: "{selected}/{total} 선택됨",
|
||
mcpScopeAllConnections: "모든 연결",
|
||
mcpScopeNoConnections: "연결 없음",
|
||
mcpScopeConnectionUnavailable: "이전에 선택한 연결 (사용 불가)",
|
||
mcpScopeConnectionUnavailableDescription: "선택한 연결 {count}개가 더 이상 존재하지 않습니다. 해당 ID는 허용 목록에 남아 있지만 현재 연결은 노출되지 않습니다.",
|
||
mcpScopeSelectedCount: "연결 {count}개 선택됨",
|
||
mcpCodexConfig: "Codex 설정",
|
||
mcpCodexConfigPath: "Codex는 ~/.codex/config.toml 또는 프로젝트 수준의 .codex/config.toml을 사용할 수 있습니다.",
|
||
mcpDeepSeekHarnessConfigPath: "dsh web에서는 이 insert 항목을 $DSH_HOME/profiles/web/cordis.patch.yml에 병합하세요. 다른 profile은 web을 바꾸면 됩니다. 기존 patch 항목을 덮어쓰지 마세요. dsh web --dump-config로 확인하거나 HMR로 변경 사항을 다시 불러올 수 있습니다.",
|
||
mcpCursorConfigPath: "Cursor는 프로젝트의 .cursor/mcp.json 또는 전역 ~/.cursor/mcp.json을 사용할 수 있습니다.",
|
||
mcpCodeBuddyConfigPath: "CodeBuddy Code는 전역 ~/.codebuddy/.mcp.json 또는 프로젝트의 .mcp.json을 사용할 수 있습니다.",
|
||
mcpZCodeConfigPath: "ZCode: 설정 > MCP 서버 > 새 MCP 서버 > 전체 구성에서 사용자 또는 작업 영역 범위를 선택한 다음 JSON 구성을 붙여넣으세요.",
|
||
mcpTraeConfigPath: "TRAE: 설정 > MCP > 추가 > 수동 추가 후 JSON 설정을 붙여넣으세요.",
|
||
mcpQoderConfigPath: "Qoder: 설정 > MCP > 수동 추가 후 JSON 설정을 붙여넣으세요.",
|
||
mcpWorkBuddyConfigPath: "WorkBuddy: 사이드바의 플러그인 → 오른쪽 위 MCP 서버 > MCP 구성에 JSON을 붙여넣어 저장하세요. 또는 ~/.workbuddy/mcp.json(전역) 또는 프로젝트의 .workbuddy/mcp.json에 저장하세요.",
|
||
mcpCherryStudioConfigPath: "Cherry Studio: 설정 > MCP 서버 > 서버 추가 > JSON 가져오기 후 설정을 붙여넣으세요.",
|
||
mcpVsCodeConfigPath: "VS Code/Copilot은 작업 영역의 .vscode/mcp.json 또는 사용자 프로필의 mcp.json을 사용할 수 있습니다.",
|
||
mcpWindsurfConfigPath: "Windsurf는 ~/.codeium/windsurf/mcp_config.json을 사용할 수 있습니다.",
|
||
mcpOpenCodeConfigPath: "전역으로 ~/.config/opencode/opencode.json, 또는 프로젝트 수준의 opencode.json입니다.",
|
||
mcpExecutionMode: "MCP 전역 기본 권한",
|
||
mcpExecutionModeDescription: "연결 또는 데이터베이스 권한이 없을 때 사용할 기본값입니다. 연결 기본값과 데이터베이스 설정은 범위에 따라 이를 재정의할 수 있습니다.",
|
||
mcpExecutionModeReadOnly: "읽기 전용",
|
||
mcpExecutionModeSafeWrite: "데이터 읽기/쓰기",
|
||
mcpExecutionModeRecommended: "권장",
|
||
mcpExecutionModeHighRiskWrite: "전체 접근",
|
||
mcpExecutionModeReadOnlyDescription: "DBX가 읽기로 분류한 요청만 허용하며, 인식된 데이터베이스 쓰기와 연결 변경을 차단합니다. 데이터베이스 계정 권한이 최종적인 hard boundary입니다.",
|
||
mcpExecutionModeSafeWriteDescription: "일반 INSERT, 필터링된 UPDATE/DELETE, 범위가 확인된 MongoDB 변경 및 일반 Redis 쓰기나 명시적 키 삭제를 허용하며 테이블 전체 및 구조 변경을 차단합니다.",
|
||
mcpExecutionModeHighRiskWriteDescription: "데이터 읽기/쓰기 외에 테이블 전체 변경, DDL, TRUNCATE, 데이터베이스 비우기 및 기타 고위험 작업을 허용합니다. 프로덕션 및 연결 읽기 전용 보호는 여전히 적용됩니다.",
|
||
mcpExecutionModeHighRiskConfirm: "전체 접근은 테이블 전체 변경, DDL, TRUNCATE, 데이터베이스 비우기 및 기타 고위험 작업을 허용합니다. 활성화하시겠습니까?",
|
||
mcpCapabilityTitle: "기능 비교",
|
||
mcpCapabilityDescription: "대표적인 작업입니다. DBX가 안정적으로 분류할 수 없는 요청은 전체 접근이 필요합니다.",
|
||
mcpCapabilityOperation: "기능",
|
||
mcpCapabilityRead: "쿼리 및 읽기",
|
||
mcpCapabilityScopedMutation: "범위가 지정된 데이터 변경 (INSERT, 필터링된 UPDATE/DELETE, 명시적 키 쓰기/삭제)",
|
||
mcpCapabilityBroadMutation: "테이블 전체 수정/삭제 및 데이터 비우기",
|
||
mcpCapabilitySchemaAdmin: "DDL, 구조 변경 및 고위험 관리",
|
||
mcpCapabilityConnectionManagement: "MCP 연결 추가/제거",
|
||
mcpCapabilityAllowed: "허용됨",
|
||
mcpCapabilityBlocked: "차단됨",
|
||
mcpQueryTimeout: "쿼리 시간 제한(초)",
|
||
mcpQueryTimeoutDescription: "비워 두면 연결의 쿼리 시간 제한 설정을 상속합니다. 0 = 제한 없음. 양수는 연결 설정을 재정의하여 모든 MCP 쿼리에 적용됩니다.",
|
||
mcpQueryTimeoutInvalid: "음수가 아닌 정수(초)를 입력하거나 비워 두어 연결 설정을 상속하십시오.",
|
||
mcpCapabilityAlwaysEnforced: "모든 모드는 연결 허용 목록, 연결 읽기 전용 보호, 프로덕션 보호 및 데이터베이스 계정 권한의 적용을 받습니다.",
|
||
mcpPolicySaveFailed: "MCP 접근 정책 저장 실패: {error}",
|
||
mcpPolicyLoadFailed: "MCP 접근 정책 불러오기 실패: {error}",
|
||
mcpDetectionTiming: "DBX는 이 페이지를 열 때 자동으로 확인합니다. 새로고침하려면 다시 확인을 사용하세요.",
|
||
mcpNpmBoundary: "DBX는 MCP 상태를 확인하고 설명만 합니다. 설치와 업그레이드는 여전히 npm을 통해 실행됩니다.",
|
||
mcpRefresh: "다시 확인",
|
||
mcpGuide: "MCP 가이드",
|
||
mcpAuthTitle: "MCP 권한 설정",
|
||
mcpAuthDescription: "순서대로 권한을 설정하세요: 전역 기본값을 정하고 그룹과 연결, 데이터베이스 범위를 설정한 뒤 최종 정책을 확인합니다.",
|
||
mcpAuthStepsLabel: "MCP 권한 설정 단계",
|
||
mcpAuthStepConnectionsTitle: "그룹 및 연결",
|
||
mcpAuthStepConnectionsDescription: "MCP에 노출할 연결을 결정합니다",
|
||
mcpAuthStepDatabasesTitle: "데이터베이스 범위",
|
||
mcpAuthStepDatabasesDescription: "연결별로 접근 가능한 데이터베이스를 제한합니다",
|
||
mcpAuthStepOverridesTitle: "기본 권한",
|
||
mcpAuthStepOverridesDescription: "이후 범위에 적용할 전역 기본 권한을 설정합니다",
|
||
mcpAuthStepCapabilitiesTitle: "요약 및 확인",
|
||
mcpAuthStepCapabilitiesDescription: "최종 권한을 검토하고 도구를 선택한 뒤 확인합니다",
|
||
mcpAuthStepRegionLabel: "단계 {step}: {title}",
|
||
mcpAuthPreviousStep: "이전",
|
||
mcpAuthNextStep: "다음",
|
||
mcpAuthStepProgress: "{total}단계 중 {current}단계",
|
||
mcpResourceScopeTitle: "MCP에 표시되는 연결",
|
||
mcpResourceScopeDescription: "동적 범위에는 그룹을 선택하고 정확한 예외에는 개별 연결을 선택하세요.",
|
||
mcpResourceScopeModeCustom: "사용자 지정 범위",
|
||
mcpResourceScopeAllSummary: "모든 {count}개 연결",
|
||
mcpResourceScopeCustomSummary: "유효 {effective}개 · 그룹 규칙 {groups}개 · 직접 규칙 {connections}개",
|
||
mcpResourceScopeSearch: "그룹 또는 연결 검색",
|
||
mcpResourceScopeTreeLabel: "MCP 연결 리소스 트리",
|
||
mcpResourceScopeInherited: "{group}에서 상속",
|
||
mcpResourceScopeDynamic: "동적",
|
||
mcpResourceScopeDirect: "직접",
|
||
mcpResourceScopePartial: "부분 허용",
|
||
mcpResourceScopeEmpty: "일치하는 그룹 또는 연결이 없습니다.",
|
||
mcpResourceScopeHint: "선택한 그룹에는 현재와 미래의 모든 하위 연결이 포함됩니다. 직접 선택은 독립적인 예외입니다.",
|
||
mcpResourceScopeAllConfirm: "모든 연결로 전환하면 현재 사용자 지정 그룹 및 연결 규칙이 제거됩니다. 계속하시겠습니까?",
|
||
mcpPermissionGlobalDefaultHint: "그룹, 연결 및 데이터베이스 권한은 이 기본값을 재정의하지만 연결 표시 범위를 확장하지는 않습니다.",
|
||
mcpDatabasePolicyHighRiskConfirm: "이 데이터베이스에 고위험 쓰기를 허용하시겠습니까? 연결 읽기 전용 및 운영 환경 보호는 계속 적용됩니다.",
|
||
mcpDatabaseScopeClearsPermissionExceptions: "이 데이터베이스 범위를 변경하면 데이터베이스 권한 예외가 제거됩니다. 계속하시겠습니까?",
|
||
mcpPermissionPreviewResource: "리소스",
|
||
mcpPermissionPreviewSource: "적용 출처",
|
||
mcpPermissionSourceDatabase: "데이터베이스 예외",
|
||
mcpPermissionSourceConnection: "연결 예외",
|
||
mcpPermissionSourceGroup: "그룹: {group}",
|
||
mcpPermissionSourceGlobal: "전역 기본값",
|
||
mcpPerPage: "페이지당",
|
||
mcpPreviousPage: "이전 페이지",
|
||
mcpNextPage: "다음 페이지",
|
||
mcpDatabaseScopeTitle: "연결 및 데이터베이스 범위",
|
||
mcpDatabaseScopeDescription: "왼쪽에서 MCP에 노출된 연결을 선택한 뒤, 해당 연결이 접근할 수 있는 데이터베이스를 제한합니다. 데이터베이스 이름은 정확히 일치해야 합니다.",
|
||
mcpDatabaseScopeEmptyHint: "먼저 '연결 범위'에서 하나 이상의 연결을 허용하세요.",
|
||
mcpDatabaseScopeAllowedConnections: "허용된 연결",
|
||
mcpDatabaseScopeSummaryAll: "모든 데이터베이스",
|
||
mcpDatabaseScopeSummaryNone: "데이터베이스 접근 없음",
|
||
mcpDatabaseScopeSummarySelected: "{count}개 선택됨",
|
||
mcpDatabaseScopePermissionNote: "범위를 선택해도 DBX에서 이 연결의 기존 데이터베이스 권한은 변경되지 않습니다.",
|
||
mcpDatabaseLoadButton: "리소스 목록 불러오기",
|
||
mcpDatabaseScopeAriaLabel: "데이터베이스 접근 범위",
|
||
mcpDatabaseScopeAllTitle: "모든 데이터베이스",
|
||
mcpDatabaseScopeAllDescription: "현재 접근 범위 유지",
|
||
mcpDatabaseScopeSelectedTitle: "지정한 데이터베이스만",
|
||
mcpDatabaseScopeSelectedDescription: "선택한 항목만 노출",
|
||
mcpDatabaseScopeNoneTitle: "접근 허용 안 함",
|
||
mcpDatabaseScopeNoneDescription: "규칙은 유지하되 모든 데이터베이스 거부",
|
||
mcpDatabaseScopeSelectedSummary: "{count}개 데이터베이스가 허용되었습니다. 선택하지 않은 데이터베이스와 크로스 데이터베이스 요청은 MCP 서버가 거부합니다.",
|
||
mcpDatabasePolicyInherit: "연결 기본값 상속",
|
||
mcpDatabasePolicySetting: "데이터베이스 우선 설정",
|
||
mcpDatabasePolicyEffective: "적용됨: {mode}",
|
||
mcpPermissionPreviewTitle: "권한 미리보기",
|
||
mcpPermissionPreviewDescription: "권한 우선순위: 데이터베이스, 연결, 가장 가까운 그룹, 상위 그룹, 전역 기본값.",
|
||
mcpPermissionPreviewConnection: "연결",
|
||
mcpPermissionPreviewDatabase: "데이터베이스",
|
||
mcpPermissionPreviewConnectionDefault: "연결 기본값",
|
||
mcpPermissionPreviewGroupDefault: "그룹 기본값",
|
||
mcpGroupScopeTitle: "연결 그룹",
|
||
mcpGroupScopeDescription: "그룹을 선택하면 현재 및 향후의 모든 하위 연결이 동적으로 노출됩니다. 다른 연결도 개별적으로 추가할 수 있습니다.",
|
||
mcpGroupScopeSelected: "{count}개 그룹 선택됨",
|
||
mcpGroupScopeSearch: "그룹 경로 검색",
|
||
mcpGroupScopeNoResults: "일치하는 그룹이 없습니다.",
|
||
mcpGroupScopeEmpty: "구성할 연결 그룹이 없습니다.",
|
||
mcpGroupPolicyTitle: "그룹 기본 권한",
|
||
mcpGroupPolicyDescription: "하위 그룹은 상위 그룹을 재정의하며 연결 및 데이터베이스 설정은 그룹 기본값을 재정의할 수 있습니다.",
|
||
mcpGroupPolicyInherit: "상위 또는 전역 상속",
|
||
mcpGroupPolicyHighRiskConfirm: "이 그룹에 고위험 쓰기를 허용하시겠습니까? 연결 읽기 전용 및 프로덕션 보호는 계속 적용됩니다.",
|
||
mcpPermissionPreviewDatabaseOverride: "데이터베이스 우선 설정",
|
||
mcpPermissionPreviewEffective: "최종 적용",
|
||
mcpPermissionPreviewEmpty: "먼저 하나 이상의 연결을 허용하고 데이터베이스 범위를 설정하세요.",
|
||
mcpPermissionPreviewSearchPlaceholder: "연결 또는 데이터베이스 검색",
|
||
mcpPermissionPreviewSearchNoResults: "일치하는 연결 또는 데이터베이스가 없습니다.",
|
||
mcpDatabaseSearchPlaceholder: "불러온 데이터베이스 필터",
|
||
mcpDatabaseManualPlaceholder: "데이터베이스 이름 직접 추가",
|
||
mcpDatabaseLoadFailed: "데이터베이스 불러오기 실패: {error}. 정확한 데이터베이스 이름을 직접 추가할 수 있습니다.",
|
||
mcpDatabaseEmptyHint: "'리소스 목록 불러오기'를 클릭해 데이터베이스 목록을 가져오거나, 허용할 데이터베이스를 직접 추가하세요.",
|
||
mcpManagementAccess: "접속 방식",
|
||
mcpManagementPermissions: "권한 관리",
|
||
mcpTransportLabel: "연결 유형",
|
||
mcpRuntimeSettings: "실행 설정",
|
||
mcpTransportLocalStdio: "로컬 stdio",
|
||
mcpTransportHttpService: "HTTP 서비스",
|
||
mcpHttpWebServiceTitle: "Web Streamable HTTP 서비스",
|
||
mcpHttpWebServiceDescription: "Web/Docker은 현재 웹 수신 포트를 재사용합니다. 배포 환경 변수로 활성화되며 설정 페이지에는 Token이 저장되지 않습니다.",
|
||
mcpHttpStatusLabelEnabled: "활성화됨",
|
||
mcpHttpStatusLabelDisabled: "비활성화됨",
|
||
mcpHttpNotConfigured: "미구성",
|
||
mcpHttpWebTokenSourceAndHosts: "Token 출처: {tokenSource}; 허용 Host: {hosts}",
|
||
mcpHttpWebAllowedOrigins: "허용 Origin: {origins}",
|
||
mcpHttpReloadStatus: "상태 다시 불러오기",
|
||
mcpHttpServiceTitle: "Streamable HTTP 서비스",
|
||
mcpHttpStatusLabelRunning: "실행 중",
|
||
mcpHttpStatusLabelPending: "적용 대기 중",
|
||
mcpHttpServiceDescription: "기본적으로 꺼져 있습니다. 활성화하면 DBX Desktop이 서비스를 호스팅하며, 저장 후에야 위 설정이 실제 수신 서비스에 적용됩니다.",
|
||
mcpHttpListenerTitle: "수신 설정",
|
||
mcpHttpListenerHintPrefix: "",
|
||
mcpHttpListenerHintSuffix: "을(를) 유지하는 것을 권장합니다. 같은 컴퓨터의 MCP 클라이언트만 연결할 수 있습니다.",
|
||
mcpHttpHostLabel: "수신 주소",
|
||
mcpHttpPortLabel: "포트",
|
||
mcpHttpPathLabel: "MCP 경로",
|
||
mcpHttpRemoteTitle: "원격 접근",
|
||
mcpHttpRemoteHintPrefix: "수신 주소가 ",
|
||
mcpHttpRemoteHintMiddle: " 또는 ",
|
||
mcpHttpRemoteHintSuffix: "이(가) 아닐 때만 필요합니다. 활성화하면 Host와 Origin 화이트리스트를 반드시 입력해야 합니다.",
|
||
mcpHttpAllowedHostsLabel: "허용할 Host",
|
||
mcpHttpHostsHint: "한 줄에 하나씩, 쉼표로 구분할 수도 있습니다.",
|
||
mcpHttpAllowedOriginsLabel: "허용할 Origin",
|
||
mcpHttpOriginsHintPrefix: "프로토콜을 포함해야 합니다(예: ",
|
||
mcpHttpOriginsHintSuffix: ").",
|
||
mcpHttpRemoteDisabledHint: "원격 접근이 꺼져 있으면 화이트리스트를 구성할 필요가 없습니다.",
|
||
mcpHttpUnsavedChangesHint: "위 설정이 아직 저장되지 않아 실행 중인 서비스는 즉시 변경되지 않습니다.",
|
||
mcpHttpSaveHint: "저장하면 서비스를 시작하거나 재시작하고 아래 접속 정보를 갱신합니다.",
|
||
mcpHttpReload: "다시 불러오기",
|
||
mcpHttpSaveAndStart: "저장하고 서비스 시작",
|
||
mcpHttpDisabledHint: "서비스를 활성화하면 수신 주소, 원격 접근 화이트리스트, 클라이언트 접속 정보를 구성할 수 있습니다.",
|
||
mcpHttpSaveAndStop: "저장하고 서비스 중지",
|
||
mcpHttpConnectionInfoTitle: "적용된 클라이언트 접속 정보",
|
||
mcpHttpServiceNotRunning: "서비스가 실행 중이 아닙니다",
|
||
mcpHttpRunningConfigBadge: "실행 설정",
|
||
mcpHttpLastStatusBadge: "최근 상태",
|
||
mcpHttpRunningDraftDiffersHint: "아래는 현재 실행 중인 서비스의 접속 정보이며, 위의 저장되지 않은 초안과 다를 수 있습니다.",
|
||
mcpHttpEndpointLabel: "서비스 주소",
|
||
mcpHttpRotateToken: "Token 교체",
|
||
mcpHttpRotateTokenConfirm: "Token을 교체하면 이전 Token을 사용하는 MCP 클라이언트가 즉시 연결 해제됩니다. 계속하시겠습니까?",
|
||
mcpHttpTokenHintPrefix: "이 값을 클라이언트 HTTP ",
|
||
mcpHttpTokenHintSuffix: " 자격 증명으로 사용하세요.",
|
||
mcpHttpClientConfigTitle: "범용 HTTP 클라이언트 설정",
|
||
mcpHttpClientConfigHint: "클라이언트마다 필드 이름이 다르므로 URL과 Authorization 값은 유지하세요.",
|
||
mcpHttpLogsTitle: "서비스 진단 로그",
|
||
mcpHttpValidationHostRequired: "수신 주소를 입력하세요.",
|
||
mcpHttpValidationPortRange: "포트는 1에서 65535 사이의 정수여야 합니다.",
|
||
mcpHttpValidationPathPrefix: "MCP 경로는 /로 시작해야 합니다.",
|
||
mcpHttpValidationRemoteRequired: "루프백이 아닌 주소로 수신하려면 '원격 접근'을 활성화하세요.",
|
||
mcpHttpValidationHostsRequired: "원격 접근에는 허용 Host를 하나 이상 입력해야 합니다.",
|
||
mcpHttpValidationOriginsRequired: "원격 접근에는 허용 Origin을 하나 이상 입력해야 합니다.",
|
||
mcpHttpErrorRemoteHostsAndOrigins: "원격 접근에는 허용 Host와 허용 Origin을 모두 입력해야 합니다.",
|
||
mcpHttpErrorRemoteBinding: "원격 수신에는 원격 접근 활성화와 Host·Origin 화이트리스트가 필요합니다.",
|
||
mcpHttpErrorPortInUse: "이 포트는 다른 애플리케이션이 사용 중입니다. DBX는 저장 시 자체 MCP 서비스를 재시작합니다. 해당 포트를 사용하는 다른 애플리케이션을 종료하거나 다른 포트를 사용하세요.",
|
||
mcpConnectionPolicyTitle: "연결 기본 권한",
|
||
mcpConnectionPolicyDescription: "노출된 각 연결의 데이터베이스 기본 권한을 설정합니다. 데이터베이스 설정이 연결 및 전역 기본값보다 우선합니다.",
|
||
mcpConnectionPolicyEmptyHint: "연결 기본 권한을 설정하려면 먼저 1단계에서 하나 이상의 연결을 허용하세요.",
|
||
mcpConnectionPolicyInherit: "전역 상속",
|
||
mcpConnectionPolicyReadOnly: "읽기 전용만",
|
||
mcpConnectionPolicySafeWrite: "안전한 쓰기 허용",
|
||
mcpConnectionPolicyHighRiskWrite: "고위험 작업 허용",
|
||
mcpToolPermissionsTitle: "MCP 도구 권한",
|
||
mcpToolPermissionsDescription: "필요한 MCP 도구만 노출하세요. 선택 해제하면 도구 정의를 캐시한 클라이언트도 서버에서 거부됩니다.",
|
||
mcpToolListConnections: "연결 나열",
|
||
mcpToolListDatabases: "데이터베이스 나열",
|
||
mcpToolListTables: "테이블 나열",
|
||
mcpToolDescribeTable: "테이블 구조",
|
||
mcpToolListRoutines: "루틴 목록",
|
||
mcpToolGetRoutineSource: "루틴 소스",
|
||
mcpToolGetSchemaContext: "Schema 컨텍스트",
|
||
mcpToolExecuteQuery: "SQL / Mongo 명령 실행",
|
||
mcpToolExecuteBatch: "SQL 배치 실행",
|
||
mcpToolOpenSession: "쿼리 세션 열기",
|
||
mcpToolCloseSession: "쿼리 세션 닫기",
|
||
mcpToolExecuteRedisCommand: "Redis 명령 실행",
|
||
mcpToolPeekMessages: "Kafka 메시지 읽기",
|
||
mcpToolSendMessage: "메시지 큐 메시지 전송",
|
||
mcpToolAddConnection: "연결 추가",
|
||
mcpToolDuplicateConnection: "연결 복제",
|
||
mcpToolRemoveConnection: "연결 삭제",
|
||
mcpToolOpenTable: "DBX에서 테이블 열기",
|
||
mcpToolExecuteAndShow: "DBX에서 실행 및 표시",
|
||
supportInfoTitle: "지원 정보",
|
||
supportInfoDescription: "이슈를 등록하거나 도움을 요청할 때 이 환경 세부 정보를 복사하세요.",
|
||
supportInfoCopy: "지원 정보 복사",
|
||
supportInfoCopied: "복사했습니다",
|
||
supportInfoLoading: "지원 정보를 불러오는 중...",
|
||
supportInfoLoadFailed: "전체 지원 정보를 불러오는 데 실패했습니다: {message}",
|
||
supportInfoAppVersion: "DBX 버전",
|
||
supportInfoRuntime: "런타임",
|
||
supportInfoRuntimeDesktop: "데스크톱",
|
||
supportInfoRuntimeWeb: "웹",
|
||
supportInfoOperatingSystem: "운영 체제",
|
||
supportInfoArchitecture: "아키텍처",
|
||
supportInfoUnknown: "알 수 없음",
|
||
settingsTransferTitle: "설정 가져오기 및 내보내기",
|
||
settingsTransferDescription: "앱 설정을 파일로 내보내 설정을 백업하거나, 백업 파일에서 설정을 복원합니다.",
|
||
settingsTransferExport: "내보내기",
|
||
settingsTransferImport: "가져오기",
|
||
settingsTransferExportSuccess: "설정을 내보냈습니다",
|
||
settingsTransferExportFailed: "설정 내보내기 실패: {message}",
|
||
settingsTransferExportChoiceTitle: "적용되지 않은 변경 사항이 있습니다",
|
||
settingsTransferExportChoiceMessage: "적용되지 않은 설정 변경 사항이 있습니다. 저장된 설정을 내보내면 이러한 변경 사항은 포함되지 않습니다.",
|
||
settingsTransferExportChoiceSaved: "저장된 설정 내보내기",
|
||
settingsTransferExportChoiceApplied: "적용 후 내보내기",
|
||
settingsTransferApplyBlocked: "해결되지 않은 설정 충돌이 있어 적용 후 내보낼 수 없습니다.",
|
||
settingsTransferImportReadFailed: "설정 파일을 읽지 못했습니다: {message}",
|
||
settingsTransferImportInvalidJson: "파일이 유효한 JSON 설정 파일이 아닙니다.",
|
||
settingsTransferImportUnsupportedVersion: "지원되지 않는 설정 파일 형식 버전: v{version}. 지원 버전: v{supported}.",
|
||
settingsTransferImportInvalidStructure: "설정 파일 구조가 올바르지 않아 가져올 수 없습니다.",
|
||
settingsTransferImportEmpty: "설정 파일에 가져올 수 있는 설정이 없습니다.",
|
||
settingsTransferImportFieldInvalid: "설정 파일에 잘못된 필드가 있어 가져오기를 취소했습니다: {fields}",
|
||
settingsTransferImportFileTooLarge: "설정 파일이 너무 큽니다. 최대 크기: {limit}.",
|
||
settingsTransferImportConfirmTitle: "설정 가져오기",
|
||
settingsTransferImportConfirmFile: "파일",
|
||
settingsTransferImportConfirmSourceVersion: "원본 앱 버전",
|
||
settingsTransferImportConfirmIncludes: "포함 항목",
|
||
settingsTransferImportConfirmDraftWarning: "다음 카테고리에는 적용되지 않은 변경 사항이 있으며, 가져오면 대체됩니다: {categories}",
|
||
settingsTransferImportConfirmAction: "설정 불러오기",
|
||
settingsTransferImportLoaded: "설정을 불러왔습니다. 저장하려면 '적용'을 클릭하세요.",
|
||
settingsTransferCategoryOther: "기타",
|
||
qqGroup: "QQ 그룹",
|
||
wechatGroup: "위챗 그룹",
|
||
wechatGroupInvite: "텐센트 문서 초대",
|
||
openSource: "오픈 소스 저장소",
|
||
officialDocs: "공식 문서",
|
||
changelogTitle: "변경 이력",
|
||
changelogDescription: "각 릴리스의 새로운 기능을 탐색하세요.",
|
||
changelogLoading: "변경 이력을 불러오는 중...",
|
||
changelogLoadFailed: "변경 이력을 불러오는 데 실패했습니다.",
|
||
changelogEmpty: "아직 변경 이력 항목이 없습니다.",
|
||
changelogPublishedOn: "{date}에 게시됨",
|
||
changelogNew: "신규",
|
||
changelogLoadMore: "더 불러오기",
|
||
changelogOpenWebsite: "웹사이트에서 보기",
|
||
changelogOpenGitHub: "GitHub 릴리스",
|
||
changelogNoDetails: "자세한 내용은 GitHub 릴리스를 참조하세요.",
|
||
changelogRetry: "다시 시도",
|
||
changelogSectionAdded: "새로운 기능",
|
||
changelogSectionImproved: "개선 사항",
|
||
changelogSectionFixed: "버그 수정",
|
||
changelogSectionChanged: "변경 사항",
|
||
changelogSectionRemoved: "제거된 항목",
|
||
shortcutUppercaseSelection: "선택 영역을 대문자로 변환",
|
||
shortcutLowercaseSelection: "선택 영역을 소문자로 변환",
|
||
shortcutExPasteSqlInCondition: "ExPaste: IN 조건으로 붙여넣기",
|
||
csvQuoteMode: "CSV 필드 따옴표",
|
||
csvQuoteModeDescription: "CSV 내보내기 시 필드에 큰따옴표를 사용하는 방식을 선택합니다.",
|
||
csvQuoteModeAll: "모든 필드",
|
||
csvQuoteModeNecessary: "필수 필드만",
|
||
shortcutConvertNamingStyle: "네이밍 스타일 전환",
|
||
dataGridKeepFilterEditorExpanded: "필터 편집기 항상 펼치기",
|
||
dataGridKeepFilterEditorExpandedDescription: "조건 및 텍스트 보기에서 편집기를 항상 펼칩니다.",
|
||
mcpQueryTimeoutSaveStatus_saving: "저장 중...",
|
||
mcpQueryTimeoutSaveStatus_saved: "저장됨",
|
||
mcpQueryTimeoutSaveStatus_failed: "저장 실패",
|
||
supportInfoUserAgent: "User-Agent",
|
||
supportInfoDatabaseTypes: "데이터베이스 유형",
|
||
supportInfoLocalDriverVersions: "로컬 드라이버 버전",
|
||
supportInfoAiProviders: "AI 제공자",
|
||
},
|
||
driverStore: {
|
||
jreDirRemoveFailed: "이전 JRE 디렉터리 제거 실패: {path} (원래 오류: {error})",
|
||
jreDirRemoveFailedWindows: "이전 JRE 디렉터리 제거 실패: {path}\n가능한 원인:\n - dbx Agent/java 프로세스가 여전히 디렉터리를 사용 중\n - 백신 소프트웨어가 검사 중\n디렉터리를 사용할 수 있는 프로세스를 닫거나 dbx를 다시 시작하고 다시 시도하세요.\n(원래 오류: {error})",
|
||
jreInUseByDrivers: "JRE {jre}은(는) 드라이버가 사용 중입니다: {drivers}. 먼저 제거하세요.",
|
||
offlinePackageRegistryMissing: "ZIP에 agent-registry.json이 없습니다. 올바른 오프라인 드라이버 패키지가 아닙니다.",
|
||
progressJreExtract: "JRE 압춑 푸는 중...",
|
||
progressDownloadJre: "JRE 다운로드",
|
||
progressDownloadDriver: "드라이버 다운로드",
|
||
progressDownloadJdbcPlugin: "JDBC 플러그인 다운로드",
|
||
progressJdbcPluginExtract: "JDBC 플러그인 설치 중...",
|
||
usageTitle: "저장 공간 사용량",
|
||
usageTotal: "전체 {size}",
|
||
usageTotalLabel: "전체",
|
||
calculating: "계산 중...",
|
||
usageManagedJre: "관리 JRE",
|
||
usageAgentDrivers: "내장 드라이버 에이전트",
|
||
usageDownloadCache: "다운로드 캐시",
|
||
usageJdbcPlugin: "JDBC 플러그인",
|
||
usageJdbcDriverJars: "JDBC 드라이버 JAR",
|
||
clearDownloadCache: "캐시 지우기",
|
||
downloadCacheClearSuccess: "다운로드 캐시를 지웠습니다",
|
||
downloadCacheClearFailed: "다운로드 캐시 지우기 실패: {error}",
|
||
driverCategoryAll: "모든 드라이버",
|
||
driverCategoryLabel: "카테고리",
|
||
offlineDownloadHint: "폐쇄망 환경의 경우 인터넷이 연결된 머신에서 오프라인 드라이버 패키지를 다운로드한 후 여기로 가져오세요.",
|
||
offlineDownloadLink: "오프라인 드라이버 다운로드",
|
||
searchDrivers: "드라이버 이름, 유형, 버전 검색...",
|
||
searchJdbcDrivers: "JDBC 드라이버 이름 또는 경로 검색...",
|
||
jdbcMavenCoordinatePlaceholder: "Maven 좌표, 예: org.postgresql:postgresql:42.7.7",
|
||
jdbcMavenInstall: "Maven에서 설치",
|
||
jdbcMavenInstallSuccess: "JDBC Maven 드라이버를 설치했습니다",
|
||
jdbcSourceMaven: "Maven",
|
||
jdbcSourceManual: "수동",
|
||
noMatchingDrivers: "일치하는 드라이버가 없습니다.",
|
||
javaRuntimeSaved: "Java 런타임 설정을 저장했습니다",
|
||
javaRuntimeSaveFailed: "Java 런타임 설정 저장 실패: {error}",
|
||
chooseJavaExecutable: "Java 실행 파일 선택",
|
||
driverInstallSuccess: "{label} 드라이버를 설치했습니다",
|
||
driverInstallFailed: "{label} 드라이버 설치 실패: {error}",
|
||
driverUpdateBlocked: "드라이버를 업데이트하기 전에 이 데이터베이스 연결을 닫으세요: {labels}",
|
||
upgradeAllSuccess: "드라이버 {count}개 업그레이드",
|
||
upgradeAllPartial: "드라이버 {count}개 업그레이드. 건너뜀: {failed}",
|
||
upgradeAllFailed: "일괄 업그레이드 실패: {error}",
|
||
driverUninstallSuccess: "{label} 드라이버를 제거했습니다",
|
||
driverUninstallFailed: "{label} 드라이버 제거 실패: {error}",
|
||
chooseOfflineDriverPackage: "오프라인 드라이버 패키지 선택",
|
||
offlineImportSuccess: "오프라인 가져오기 완료. 드라이버 {count}개 설치.",
|
||
offlineJreImportSuccess: "오프라인 가져오기 완료. JRE {jreCount}개 설치.",
|
||
offlineImportWithJreSuccess: "오프라인 가져오기 완료. JRE {jreCount}개와 드라이버 {count}개 설치.",
|
||
offlineImportFailed: "오프라인 가져오기 실패: {error}",
|
||
driverImportSuccess: "{label} 드라이버를 가져왔습니다",
|
||
driverImportFailed: "{label} 드라이버 가져오기 실패: {error}",
|
||
chooseDriverJar: "드라이버 파일 선택",
|
||
jreReinstallSuccess: "JRE {jre}을(를) 다시 설치했습니다",
|
||
jreReinstallFailed: "JRE {jre} 다시 설치 실패: {error}",
|
||
jreUninstallSuccess: "JRE {jre}을(를) 제거했습니다",
|
||
chooseJdbcPluginZip: "JDBC 플러그인 zip 파일 선택",
|
||
agentDrivers: "내장 드라이버",
|
||
jdbcDrivers: "JDBC 드라이버",
|
||
importing: "가져오는 중...",
|
||
importOfflinePackage: "오프라인 패키지 가져오기",
|
||
offlineExport: "오프라인 패키지 내보내기",
|
||
offlineExportTitle: "Agent 오프라인 패키지 내보내기",
|
||
offlineExportDescription: "포함할 DBX 관리 Agent 드라이버를 선택하세요. 패키지는 현재 플랫폼에서만 사용할 수 있습니다.",
|
||
offlineExportPlatform: "대상 플랫폼",
|
||
offlineExportSelectedCount: "{total}개 중 {selected}개 선택",
|
||
offlineExportSelectAll: "모두 선택",
|
||
offlineExportClear: "선택 해제",
|
||
offlineExportNoDrivers: "내보낼 수 있는 DBX 관리 Agent 드라이버가 설치되어 있지 않습니다.",
|
||
offlineExportArtifactJar: "Java JAR",
|
||
offlineExportArtifactNative: "네이티브",
|
||
offlineExportArtifactUnknown: "알 수 없음",
|
||
offlineExportPreparing: "내보내기 미리보기를 준비하는 중...",
|
||
offlineExportJreSummary: "필요한 관리 JRE {count}개가 자동으로 포함됩니다.",
|
||
offlineExportSecurityHint: "DBX 관리 아티팩트와 필요한 JRE만 포함됩니다. 로컬 경로, 설정 및 외부 드라이버는 제외됩니다.",
|
||
offlineExportStart: "드라이버 {count}개 내보내기",
|
||
offlineExporting: "내보내는 중...",
|
||
offlineExportPreviewFailed: "내보내기를 준비할 수 없습니다: {error}",
|
||
offlineExportChooseDestination: "Agent 오프라인 패키지 저장",
|
||
offlineExportSuccess: "{file} 내보내기 완료: 드라이버 {drivers}개, JRE {jres}개, {size}.",
|
||
offlineExportFailed: "오프라인 패키지 내보내기 실패: {error}",
|
||
offlineExportUnavailable_unmanagedInstall: "이 아티팩트는 DBX 관리 설치로 기록되어 있지 않습니다.",
|
||
offlineExportUnavailable_localInstall: "로컬에서 가져온 Agent 빌드는 포함되지 않습니다.",
|
||
offlineExportUnavailable_launchConfig: "사용자 지정 실행 설정은 이 컴퓨터에만 적용됩니다.",
|
||
offlineExportUnavailable_missingArtifact: "설치된 Agent 아티팩트가 없습니다.",
|
||
offlineExportUnavailable_invalidArtifact: "설치된 Agent 아티팩트가 유효하지 않거나 손상되었습니다.",
|
||
offlineExportUnavailable_unsafeSource: "아티팩트가 관리 저장소 밖에 있거나 심볼릭 링크를 사용합니다.",
|
||
offlineExportUnavailable_externalDriverRequired: "이 Agent에는 사용자가 제공하는 외부 드라이버가 필요합니다.",
|
||
offlineExportUnavailable_missingManagedJre: "필요한 DBX 관리 JRE가 설치되어 있지 않습니다.",
|
||
offlineExportUnavailable_invalidManagedJre: "필요한 DBX 관리 JRE가 유효하지 않거나 안전하지 않습니다.",
|
||
refresh: "새로고침",
|
||
javaRuntime: "Java 런타임",
|
||
javaRuntimeManaged: "DBX 관리 JRE",
|
||
javaRuntimeSystem: "시스템 Java",
|
||
javaRuntimeCustom: "사용자 지정 경로",
|
||
saving: "저장 중...",
|
||
customJavaPathPlaceholder: "/path/to/java 또는 /path/to/jdk",
|
||
choose: "선택",
|
||
systemJavaHint: "현재 PATH의 java를 사용합니다.",
|
||
jreRuntimeTitle: "JRE {jre} 런타임",
|
||
notInstalled: "설치되지 않음",
|
||
reinstalling: "다시 설치 중",
|
||
installing: "설치 중",
|
||
install: "설치",
|
||
reinstall: "다시 설치",
|
||
uninstall: "제거",
|
||
jreRuntime: "JRE 런타임",
|
||
jreRuntimeAutoDownloadHint: "처음으로 드라이버를 설치할 때 자동으로 다운로드됩니다",
|
||
driversUpdatable: "드라이버 {count}개를 업데이트할 수 있습니다",
|
||
updatesAvailableTitle: "업데이트 가능",
|
||
updatesAvailableDescription: "아래 드라이버의 새 버전이 있습니다. 최신 기능과 수정을 받으려면 업데이트하세요.",
|
||
allDriversTitle: "모든 드라이버",
|
||
upgradingProgress: "업그레이드 중 ({current}/{total})",
|
||
upgradeAll: "모두 업그레이드",
|
||
queued: "대기 중",
|
||
importLocalJar: "로컬 드라이버 파일 가져오기",
|
||
updating: "업데이트 중",
|
||
update: "업데이트",
|
||
localInstall: "로컬 설치",
|
||
localInstallHint: "완전한 폐쇄망 환경의 경우: 인터넷에 연결된 다른 컴퓨터에서 DBX GitHub Releases 페이지의 공식 dbx-jdbc-plugin-*.zip을 다운로드한 뒤 이 기기로 옮겨 선택하세요. 이 기기는 네트워크에 연결할 필요가 없습니다.",
|
||
runtimeDrivers: "런타임",
|
||
pluginsTab: "플러그인",
|
||
pluginContributionsTitle: "프론트엔드 플러그인 확장",
|
||
pluginContributionsDescription: "설치된 플러그인은 DBX 기본 창에 코드를 주입하지 않고 연결 양식과 기타 UI 확장을 선언할 수 있습니다.",
|
||
noInstalledPlugins: "설치된 플러그인이 없습니다",
|
||
noInstalledPluginsDescription: "백엔드 플러그인을 설치하면 여기에서 프론트엔드 확장을 미리 볼 수 있습니다.",
|
||
pluginHostPreview: "호스트 API 미리보기",
|
||
pluginNoFrontendContribution: "이 플러그인은 아직 프론트엔드 확장을 선언하지 않았습니다.",
|
||
storageTab: "저장 공간",
|
||
runtimeTitle: "드라이버 런타임",
|
||
runtimeHint: "런타임 메트릭은 이 패널이 열려 있는 동안에만 수집됩니다.",
|
||
runtimeRunning: "실행 중",
|
||
runtimeMemory: "메모리",
|
||
runtimeHealth: "상태",
|
||
runtimeHealth_healthy: "정상",
|
||
runtimeHealth_warning: "경고",
|
||
runtimeHealth_error: "오류",
|
||
runtimeLastError: "마지막 오류",
|
||
runtimeEmpty: "아직 드라이버 런타임이 없습니다. 에이전트 구동 연결을 열어 시작하세요.",
|
||
runtimeKindAgent: "에이전트",
|
||
runtimeKindPlugin: "플러그인",
|
||
runtimeSourceDaemon: "데몬",
|
||
runtimeSourceConnection: "연결",
|
||
runtimeStatus_running: "실행 중",
|
||
runtimeStatus_stopped: "중지됨",
|
||
runtimeStatus_error: "오류",
|
||
runtimeStatus_unknown: "알 수 없음",
|
||
runtimePid: "PID",
|
||
runtimeUptime: "가동 시간",
|
||
runtimeActions: "작업",
|
||
runtimeStop: "중지",
|
||
runtimeRestart: "다시 시작",
|
||
runtimeControlConnectionOwned: "이 런타임을 중지하려면 데이터베이스 연결을 닫으세요.",
|
||
runtimeStopSuccess: "{label} 런타임 중지됨",
|
||
runtimeStopFailed: "{label} 중지 실패: {error}",
|
||
runtimeRestartSuccess: "{label} 런타임 다시 시작됨",
|
||
runtimeRestartFailed: "{label} 다시 시작 실패: {error}",
|
||
driverStoreDir: "드라이버 저장소 경로",
|
||
driverStoreDirDescription: "JDBC 플러그인과 Agent/JRE 데이터에 대해 별도의 저장 위치를 설정합니다. 마이그레이션 후 앱이 자동으로 다시 시작됩니다.",
|
||
pluginStoreDir: "JDBC 플러그인 디렉터리",
|
||
pluginStoreDirDescription: "JDBC 플러그인, Maven 확인자, JDBC 드라이버 JAR을 저장합니다.",
|
||
agentStoreDir: "Agent / JRE 디렉터리",
|
||
agentStoreDirDescription: "Agent 드라이버 패키지, 관리 JRE, 런타임 캐시를 저장합니다.",
|
||
driverStoreDirDefault: "기본값 (설치 디렉터리)",
|
||
driverStoreDirChange: "변경",
|
||
driverStoreDirReset: "기본값으로 재설정",
|
||
driverStoreDirMigrating: "{target} 마이그레이션 중…",
|
||
driverStoreDirConfirm: "{target}을(를) 변경하면 관련 드라이버 데이터를 새 위치로 마이그레이션합니다. 마이그레이션 중 관련 드라이버 연결이 끊길 수 있습니다. 마이그레이션 후 앱이 자동으로 다시 시작됩니다. 계속하시겠습니까?",
|
||
driverStoreDirMigrationFailed: "드라이버 저장소 마이그레이션 실패: {error}",
|
||
driverStoreDirDialogTitle: "{target} 선택",
|
||
driverStoreDirSuccess: "{target} 변경됨, 다시 시작 중…",
|
||
},
|
||
databaseExport: {
|
||
title: "데이터베이스 내보내기",
|
||
options: "옵션",
|
||
includeStructure: "테이블 구조 (DDL)",
|
||
includeCreateDatabase: "데이터베이스 설정 포함 (CREATE DATABASE / USE)",
|
||
dropTableIfExists: "DDL 앞에 DROP TABLE IF EXISTS 추가",
|
||
omitAutoIncrement: "AUTO_INCREMENT 생략 (초기 설치 스크립트용)",
|
||
includeData: "테이블 데이터 (INSERT)",
|
||
includeObjects: "뷰 / 프로시저 / 함수 / 시퀀스",
|
||
splitSqlOutput: "SQL 내보내기를 ZIP 압축 파일로 분할",
|
||
splitSqlPartMaxMb: "SQL 파트당 최대 크기(MB)",
|
||
splitSqlOutputDescription: "번호가 지정된 SQL 파트와 매니페스트가 포함된 ZIP 압축 파일을 만듭니다. 파트는 완전한 SQL 문 사이에서 분할됩니다({min}–{max} MB).",
|
||
databaseSelection: "데이터베이스",
|
||
selectedDatabases: "{selected}/{total} 선택됨",
|
||
selectAllDatabases: "모두 선택",
|
||
filterDatabases: "데이터베이스 검색...",
|
||
clearDatabases: "지우기",
|
||
tableSelection: "테이블",
|
||
selectedTables: "{selected}/{total} 선택됨",
|
||
selectAllTables: "모두 선택",
|
||
filterTables: "테이블 검색...",
|
||
clearTables: "지우기",
|
||
loadingTables: "테이블 불러오는 중...",
|
||
tableLoadError: "테이블을 불러오는 데 실패했습니다: {error}",
|
||
noTables: "테이블이 없습니다",
|
||
export: "내보내기",
|
||
exportAllDatabases: "모든 데이터베이스 내보내기",
|
||
exporting: "내보내는 중...",
|
||
selectExportDirectory: "내보낼 디렉터리 선택",
|
||
currentDatabase: "데이터베이스 {current}/{total}",
|
||
currentTable: "현재: {table} ({current}/{total})",
|
||
rowsExported: "{current}/{total} 객체 처리됨, {count}행 내보냄",
|
||
allRowsExported: "총 내보낸 행: {count}",
|
||
exportSuccess: "데이터베이스를 성공적으로 내보냈습니다",
|
||
exportAllSuccess: "데이터베이스 {count}개를 성공적으로 내보냈습니다",
|
||
exportSuccessWithErrors: "내보내기가 완료되었지만 {count}개 객체가 실패했습니다: {firstError}… 자세한 내용은 내보낸 파일의 -- ERROR 주석을 참조하세요.",
|
||
exportAllSuccessWithErrors: "데이터베이스 {count}개를 내보냈지만 {errorCount}개 객체가 실패했습니다: {firstError}… 자세한 내용은 파일의 -- ERROR 주석을 참조하세요.",
|
||
allDatabasesTask: "모든 데이터베이스 ({count})",
|
||
allSchemas: "모든 스키마",
|
||
exportError: "내보내기 실패: {error}",
|
||
exportCancelled: "내보내기 취소됨",
|
||
runInBackground: "백그라운드에서 실행",
|
||
},
|
||
databaseBackup: {
|
||
title: "데이터베이스 백업",
|
||
schedules: "백업 일정",
|
||
runtimeRequirement: "예약된 백업은 DBX가 열려 있는 동안(트레이에 최소화된 경우 포함) 실행됩니다.",
|
||
addSchedule: "일정 추가",
|
||
noSupportedConnections: "백업 일정을 추가하려면 먼저 MySQL 또는 PostgreSQL 연결을 만들어 주세요.",
|
||
editSchedule: "일정 편집",
|
||
defaultScheduleName: "데이터베이스 백업",
|
||
noSchedules: "백업 일정이 없습니다",
|
||
scheduleName: "일정 이름",
|
||
connection: "연결",
|
||
missingConnection: "연결 누락",
|
||
destination: "대상 디렉터리",
|
||
selectDestination: "백업 디렉터리 선택",
|
||
outputPathTemplate: "출력 경로 템플릿",
|
||
outputPathPreview: "출력 경로 미리 보기",
|
||
fileNamePattern: "파일 이름 템플릿",
|
||
fileNamePatternHint: "{'{'}schedule{'}'}, {'{'}date{'}'}, {'{'}timestamp{'}'}, {'{'}database{'}'}, {'{'}runId{'}'}를 사용할 수 있습니다. DBX는 누락된 {'{'}database{'}'}를 추가하고 확장자도 자동으로 추가합니다.",
|
||
templateVariablesHelp: "사용 가능한 변수 설명 보기",
|
||
templateVariablesTitle: "사용 가능한 변수",
|
||
templateVariableSchedule: "백업 일정 이름",
|
||
templateVariableDate: "YYYYMMDD 형식의 백업 날짜",
|
||
templateVariableTimestamp: "백업 출력 경로에 사용하는 타임스탬프",
|
||
templateVariableDatabase: "현재 데이터베이스 백업 대상 이름",
|
||
templateVariableRunId: "이번 백업 실행 ID의 앞 8자",
|
||
fileNamePatternInvalid: "경로 구분 기호, 예약 문자, 끝의 마침표나 공백이 없는 파일 이름을 사용하세요.",
|
||
runDirectoryPattern: "실행 디렉터리 템플릿",
|
||
runDirectoryPatternHint:
|
||
"대상 디렉터리 아래의 상대 경로입니다. {'{'}schedule{'}'}, {'{'}date{'}'}, {'{'}timestamp{'}'}, {'{'}runId{'}'}를 사용할 수 있습니다. 기본 템플릿에는 더 나은 분리를 위해 {'{'}runId{'}'}가 포함됩니다. 예: {'{'}schedule{'}'}/{'{'}date{'}'}/{'{'}timestamp{'}'}-{'{'}runId{'}'}",
|
||
runDirectoryPreview: "디렉터리 미리 보기",
|
||
runDirectoryPatternInvalid: ". 또는 .. 경로 세그먼트가 없는 상대 경로를 사용하세요.",
|
||
databases: "데이터베이스",
|
||
allDatabases: "모든 데이터베이스",
|
||
databaseCount: "데이터베이스 {count}개",
|
||
tableScope: "테이블 범위",
|
||
allTables: "모든 테이블과 뷰",
|
||
includeTables: "일치 항목만 포함",
|
||
excludeTables: "일치 항목 제외",
|
||
tablePatterns: "테이블 이름 규칙",
|
||
tablePatternsPlaceholder: "orders, audit_*, public.users",
|
||
tablePatternsHint: "규칙은 쉼표로 구분하세요. *와 ? 와일드카드 및 schema.table을 지원합니다.",
|
||
includedTablePatterns: "포함 규칙 {count}개",
|
||
excludedTablePatterns: "제외 규칙 {count}개",
|
||
frequency: "빈도",
|
||
frequencyHourly: "몇 시간마다",
|
||
frequencyDaily: "매일",
|
||
frequencyWeekly: "매주",
|
||
intervalHours: "간격 (시간)",
|
||
time: "시간",
|
||
weekday: "요일",
|
||
retention: "최근 실행 보관",
|
||
contents: "백업 내용",
|
||
enabled: "일정 활성화",
|
||
enabledHint: "다음 실행은 로컬 시간대 기준으로 계산됩니다.",
|
||
nextRun: "다음: {time}",
|
||
nextRunPreview: "다음 실행: {time}",
|
||
keepRuns: "{count}개 보관",
|
||
everyHours: "{count}시간마다",
|
||
dailyAt: "매일 {time}",
|
||
weeklyAt: "{weekday} {time}",
|
||
never: "없음",
|
||
enable: "일정 활성화",
|
||
disable: "일정 비활성화",
|
||
runNow: "지금 백업",
|
||
cancel: "백업 취소",
|
||
edit: "편집",
|
||
delete: "삭제",
|
||
scheduleCreated: "백업 일정을 만들었습니다",
|
||
scheduleUpdated: "백업 일정을 업데이트했습니다",
|
||
deleteSchedule: "일정 삭제",
|
||
deleteScheduleConfirm: '일정 "{name}"을(를) 삭제하시겠습니까? 기존 백업 파일은 기록에 남습니다.',
|
||
cannotDeleteRunningSchedule: "실행 중인 백업 일정은 삭제할 수 없습니다",
|
||
history: "백업 기록",
|
||
noHistory: "아직 백업이 없습니다",
|
||
showFiles: "백업 파일 보기",
|
||
scheduledTrigger: "예약",
|
||
manualTrigger: "수동",
|
||
fileCount: "파일 {count}개",
|
||
progress: "백업 진행률",
|
||
renameBackup: "백업 이름 변경",
|
||
backupName: "백업 이름",
|
||
backupRenamed: "백업 이름이 변경되었습니다",
|
||
revealFile: "파일 관리자에서 보기",
|
||
restore: "복원",
|
||
deleteBackup: "백업 삭제",
|
||
deleteBackupConfirm: "이 백업과 SQL 파일 {count}개를 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.",
|
||
deleteBackupsConfirm: "{count}개의 백업과 SQL 파일 {files}개를 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.",
|
||
backupDeleted: "백업을 삭제했습니다",
|
||
backupsDeleted: "{count}개의 백업을 삭제했습니다",
|
||
runSuccess: "백업 완료 (파일 {count}개)",
|
||
runCancelled: "백업 취소됨",
|
||
runFailed: "백업 실패: {error}",
|
||
unknownError: "알 수 없는 오류",
|
||
status: {
|
||
running: "실행 중",
|
||
success: "완료",
|
||
failed: "실패",
|
||
cancelled: "취소됨",
|
||
},
|
||
weekdays: {
|
||
sunday: "일요일",
|
||
monday: "월요일",
|
||
tuesday: "화요일",
|
||
wednesday: "수요일",
|
||
thursday: "목요일",
|
||
friday: "금요일",
|
||
saturday: "토요일",
|
||
},
|
||
compression: "압축",
|
||
compressionNone: "압축 안 함(.sql)",
|
||
compressionGzip: "Gzip 압축(.sql.gz)",
|
||
searchConnections: "연결 검색…",
|
||
noMatchingConnections: "일치하는 연결을 찾을 수 없습니다.",
|
||
searchDatabases: "데이터베이스 검색…",
|
||
noMatchingDatabases: "일치하는 데이터베이스를 찾을 수 없습니다.",
|
||
databaseListLoadFailed: "{name}의 데이터베이스를 불러올 수 없습니다. 연결을 확인하거나 다른 연결을 선택하세요.",
|
||
cancelling: "취소 중…",
|
||
cancelRequested: "백업 취소가 요청되었습니다. 현재 작업을 중지하는 중입니다.",
|
||
allConnections: "모든 연결",
|
||
searchHistoryConnections: "연결 검색…",
|
||
backupMethod: "백업 방식",
|
||
allBackupMethods: "모든 방식",
|
||
backupStatus: "백업 상태",
|
||
allStatuses: "모든 상태",
|
||
noFilteredHistory: "일치하는 백업 기록이 없습니다.",
|
||
selectAllFiltered: "현재 필터 결과 모두 선택",
|
||
selectRun: "{name} 선택",
|
||
selectedRuns: "{count}개 선택됨",
|
||
deleteSelected: "선택 항목 삭제",
|
||
},
|
||
mqTopics: {
|
||
title: "토픽",
|
||
searchPlaceholder: "토픽 검색",
|
||
includeNonPersistent: "비지속적 토픽 포함",
|
||
refresh: "새로고침",
|
||
refreshing: "새로고침 중...",
|
||
createTopic: "토픽 만들기",
|
||
selectTenantNamespace: "먼저 테넌트와 네임스페이스를 선택하세요",
|
||
loading: "불러오는 중...",
|
||
noTopics: "이 네임스페이스에 토픽이 없습니다",
|
||
noMatches: "일치하는 토픽이 없습니다",
|
||
name: "이름",
|
||
type: "유형",
|
||
partitions: "파티션",
|
||
actions: "작업",
|
||
nonPersistent: "비지속적",
|
||
partitionedTopic: "파티션 토픽",
|
||
normalTopic: "일반 토픽",
|
||
systemTopic: "시스템 토픽",
|
||
includeSystemTopics: "시스템 토픽 포함",
|
||
noUserTopics: "사용자 토픽이 없습니다. 내부, 재시도 또는 DLQ 토픽을 검사하려면 유형 필터를 활성화하세요.",
|
||
typeFilter: "유형 필터",
|
||
messageType: "메시지 유형",
|
||
messageTypeHint: "RocketMQ Dashboard와 일치하게 브로커 토픽 구성에 message.type을 유지합니다.",
|
||
rocketmqType: {
|
||
normal: "일반",
|
||
delay: "지연",
|
||
fifo: "순서 보장",
|
||
transaction: "트랜잭션",
|
||
unspecified: "미지정",
|
||
retry: "재시도",
|
||
dlq: "데드 레터",
|
||
system: "시스템",
|
||
},
|
||
partitionCount: "파티션 {count}개",
|
||
partitionsUnknown: "알 수 없는 파티션",
|
||
adjustPartitions: "파티션 조정",
|
||
delete: "삭제",
|
||
tenantNamespace: "테넌트 / 네임스페이스",
|
||
topicName: "토픽 이름",
|
||
topicNamePlaceholder: "예: my-topic",
|
||
persistentRecommended: "지속적 토픽 (권장)",
|
||
persistentHint: "지속적 토픽은 메시지를 디스크에 저장하며, 비지속적 토픽은 메모리에만 보관합니다.",
|
||
enablePartitions: "파티션 활성화",
|
||
partitionQuantity: "파티션 수",
|
||
partitionHint: "파티션은 동시성을 향상시킬 수 있지만 리소스 사용량을 증가시킵니다.",
|
||
cancel: "취소",
|
||
create: "만들기",
|
||
updatePartitionsTitle: "파티션 조정: {name}",
|
||
currentPartitions: "현재 파티션",
|
||
newPartitions: "새 파티션",
|
||
partitionMinHint: "파티션은 늘릴 수만 있고 줄일 수는 없습니다. 최소: {min}",
|
||
update: "업데이트",
|
||
readOnly: "이 연결은 읽기 전용이며 쓰기 작업을 수행할 수 없습니다.",
|
||
topicNameRequired: "토픽 이름은 필수입니다",
|
||
currentPartitionsUnknown: "현재 파티션 수를 알 수 없어 파티션을 안전하게 조정할 수 없습니다.",
|
||
partitionMustIncrease: "새 파티션 수는 현재 파티션 수보다 커야 합니다.",
|
||
confirmDelete: '토픽 "{name}"을(를) 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.',
|
||
queues: "큐",
|
||
tabQueues: "큐",
|
||
tabExchanges: "익스체인지",
|
||
queueCount: "큐 {count}개",
|
||
clusterName: "클러스터",
|
||
brokerName: "브로커",
|
||
allBrokers: "모든 마스터 브로커",
|
||
readQueues: "읽기 큐",
|
||
writeQueues: "쓰기 큐",
|
||
perm: "권한",
|
||
permReadWrite: "읽기 + 쓰기 (6)",
|
||
permRead: "읽기 전용 (4)",
|
||
permWrite: "쓰기 전용 (2)",
|
||
actionStatus: "상태",
|
||
actionRoute: "라우트",
|
||
actionConsumers: "컨슈머",
|
||
actionConfig: "구성",
|
||
actionSend: "보내기",
|
||
actionMessageQuery: "메시지 쿼리",
|
||
actionReset: "오프셋 재설정",
|
||
actionSkip: "백로그 건너뛰기",
|
||
topicStatusTitle: "토픽 상태: {name}",
|
||
topicRouteTitle: "토픽 라우트: {name}",
|
||
topicConsumersTitle: "컨슈머: {name}",
|
||
topicConfigTitle: "토픽 구성: {name}",
|
||
topicConfigHint: "RocketMQ Dashboard와 동일: 읽기/쓰기 큐 수와 권한만 편집 가능합니다. 메시지 유형은 토픽을 만들 때 설정됩니다.",
|
||
topicResetTitle: "오프셋 재설정: {name}",
|
||
topicSkipTitle: "적재 건너뛰기: {name}",
|
||
confirmSkip: '토픽 "{name}"의 모든 컨슈머 그룹에 대해 백로그를 건너뛰시겠습니까?',
|
||
skipHint: "이 토픽에 대해 구독된 모든 컨슈머 그룹을 최신 오프셋으로 재설정합니다.",
|
||
saveConfig: "구성 저장",
|
||
resetPosition: "위치 재설정",
|
||
positionEarliest: "처음",
|
||
positionLatest: "최신",
|
||
positionTimestamp: "시간 기준",
|
||
timestamp: "시간",
|
||
invalidTimestamp: "올바른 시간을 입력하세요",
|
||
resetTimePreview: "선택한 시간: {time}",
|
||
noConsumerGroups: "컨슈머 그룹이 없습니다",
|
||
noConsumers: "이 토픽에 구독한 컨슈머 그룹이 없습니다",
|
||
manageConsumers: "관리",
|
||
routeQueues: "큐 데이터",
|
||
routeBrokers: "브로커 데이터",
|
||
brokerAddrs: "브로커 주소",
|
||
noRouteData: "라우트 데이터가 없습니다",
|
||
noQueueStats: "큐 통계가 없습니다",
|
||
noConfig: "반환된 토픽 구성이 없습니다",
|
||
queueId: "큐",
|
||
beginOffset: "최소 오프셋",
|
||
endOffset: "최대 오프셋",
|
||
messageCount: "메시지",
|
||
rabbitmqQueueType: "유형",
|
||
rabbitmqQueueTypeHint: "Management API가 보고한 큐 유형(type 또는 x-queue-type): classic / quorum / stream",
|
||
rabbitmqQueueTypeUnknown: "큐",
|
||
rabbitmqFeatures: "기능",
|
||
rabbitmqState: "상태",
|
||
rabbitmqArguments: "인수",
|
||
consumers: "소비자",
|
||
rabbitmqRates: "전송률",
|
||
rabbitmqPublishRate: "게시",
|
||
rabbitmqDeliverRate: "전달/획득",
|
||
rabbitmqAckRate: "ACK",
|
||
},
|
||
mqExchanges: {
|
||
searchPlaceholder: "익스체인지 검색",
|
||
refresh: "새로고침",
|
||
refreshing: "새로고침 중...",
|
||
createExchange: "익스체인지 만들기",
|
||
selectNamespace: "먼저 가상 호스트를 선택하세요",
|
||
loading: "불러오는 중...",
|
||
noExchanges: "이 가상 호스트에 익스체인지가 없습니다",
|
||
noMatches: "일치하는 익스체인지가 없습니다",
|
||
name: "이름",
|
||
type: "유형",
|
||
durable: "지속성",
|
||
autoDelete: "자동 삭제",
|
||
actions: "작업",
|
||
builtin: "내장",
|
||
viewBindings: "바인딩",
|
||
delete: "삭제",
|
||
yes: "예",
|
||
no: "아니오",
|
||
bindingsTitle: "{name}의 바인딩",
|
||
bindDestination: "바인딩",
|
||
noBindings: "이 익스체인지의 바인딩이 없습니다",
|
||
bindingSource: "소스",
|
||
bindingDestination: "대상",
|
||
bindingType: "유형",
|
||
routingKey: "라우팅 키",
|
||
arguments: "인자",
|
||
unbind: "바인딩 해제",
|
||
destinationTypeQueue: "큐",
|
||
destinationTypeExchange: "익스체인지",
|
||
virtualHost: "가상 호스트",
|
||
namePlaceholder: "예: dbx-events",
|
||
cancel: "취소",
|
||
create: "만들기",
|
||
bind: "바인딩",
|
||
bindDialogTitle: "{name}에 바인딩",
|
||
queueNamePlaceholder: "예: dbx-queue",
|
||
exchangeNamePlaceholder: "예: dbx-events",
|
||
routingKeyPlaceholder: "예: orders.*",
|
||
argumentsPlaceholder: "선택 JSON 객체, 예: {'{'}\"x-match\": \"all\"{'}'}",
|
||
nameRequired: "익스체인지 이름은 필수입니다",
|
||
destinationRequired: "대상은 필수입니다",
|
||
argumentsMustBeObject: "인자는 JSON 객체여야 합니다",
|
||
readOnly: "이 연결은 읽기 전용이며 쓰기 작업을 수행할 수 없습니다.",
|
||
confirmDelete: '익스체인지 "{name}"을(를) 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.',
|
||
confirmUnbind: '"{source}"에서 "{destination}"의 바인딩을 제거하시겠습니까?',
|
||
},
|
||
mqClientConnections: {
|
||
searchPlaceholder: "연결 검색",
|
||
refresh: "새로고침",
|
||
refreshing: "새로고침 중...",
|
||
loading: "불러오는 중...",
|
||
noConnections: "클라이언트 연결이 없습니다",
|
||
noMatches: "일치하는 연결이 없습니다",
|
||
name: "이름",
|
||
user: "사용자",
|
||
peerAddress: "피어 주소",
|
||
state: "상태",
|
||
channels: "채널",
|
||
recvRate: "수신 비율",
|
||
sendRate: "송신 비율",
|
||
connectedAt: "연결 시간",
|
||
actions: "작업",
|
||
closeConnection: "연결 닫기",
|
||
confirmClose: '연결 "{name}"을(를) 닫으시겠습니까? 모든 채널이 닫히며 되돌릴 수 없습니다.',
|
||
readOnly: "이 연결은 읽기 전용이며 쓰기 작업이 비활성화되었습니다.",
|
||
noChannels: "이 연결에 채널이 없습니다",
|
||
channelName: "채널",
|
||
prefetch: "프리페치",
|
||
unacked: "미확인",
|
||
consumers: "컨슈머",
|
||
},
|
||
mqUserPermissions: {
|
||
usersTitle: "사용자",
|
||
permissionsTitle: "권한",
|
||
refresh: "새로고침",
|
||
refreshing: "새로고침 중...",
|
||
loading: "불러오는 중...",
|
||
createUser: "사용자 만들기",
|
||
grantPermission: "권한 부여",
|
||
searchUsers: "사용자 검색",
|
||
noUsers: "사용자가 없습니다",
|
||
noUserMatches: "일치하는 사용자가 없습니다",
|
||
name: "이름",
|
||
tags: "태그",
|
||
actions: "작업",
|
||
delete: "삭제",
|
||
confirmDeleteUser: '사용자 "{name}"을(를) 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.',
|
||
password: "비밀번호",
|
||
tagsPlaceholder: "쉼표로 구분, 예: administrator, monitoring",
|
||
nameRequired: "사용자 이름은 필수입니다",
|
||
passwordRequired: "비밀번호는 필수입니다",
|
||
cancel: "취소",
|
||
create: "만들기",
|
||
user: "사용자",
|
||
vhost: "가상 호스트",
|
||
configure: "구성",
|
||
write: "쓰기",
|
||
read: "읽기",
|
||
noPermissions: "권한이 없습니다",
|
||
revoke: "회수",
|
||
confirmRevoke: '가상 호스트 "{vhost}"에서 사용자 "{user}"의 권한을 회수하시겠습니까?',
|
||
grant: "부여",
|
||
selectUser: "사용자를 선택하세요",
|
||
selectVhost: "가상 호스트를 선택하세요",
|
||
patternHint: "리소스 이름과 일치하는 정규 표현식이며 비워두면 .* (전체)가 기본값입니다.",
|
||
userRequired: "사용자를 선택하세요",
|
||
vhostRequired: "가상 호스트를 선택하세요",
|
||
readOnly: "이 연결은 읽기 전용이며 쓰기 작업이 비활성화되었습니다.",
|
||
},
|
||
mqRabbitMqPolicies: {
|
||
title: "정책",
|
||
refresh: "새로고침",
|
||
refreshing: "새로고침 중...",
|
||
loading: "불러오는 중...",
|
||
createPolicy: "정책 만들기",
|
||
editPolicy: "정책 편집",
|
||
noPolicies: "정책이 없습니다",
|
||
name: "이름",
|
||
vhost: "가상 호스트",
|
||
pattern: "패턴",
|
||
applyTo: "적용 대상",
|
||
priority: "우선순위",
|
||
definition: "정의",
|
||
actions: "작업",
|
||
edit: "편집",
|
||
delete: "삭제",
|
||
confirmDelete: '가상 호스트 "{vhost}"의 정책 "{name}"을(를) 삭제하시겠습니까?',
|
||
cancel: "취소",
|
||
save: "저장",
|
||
selectVhost: "가상 호스트를 선택하세요",
|
||
definitionKey: "키",
|
||
definitionValue: "값",
|
||
addDefinition: "정의 항목 추가",
|
||
patternHint: "큐/익스체인지 이름과 일치하는 정규 표현식입니다.",
|
||
nameRequired: "정책 이름은 필수입니다",
|
||
vhostRequired: "가상 호스트를 선택하세요",
|
||
patternRequired: "패턴은 필수입니다",
|
||
readOnly: "이 연결은 읽기 전용이며 쓰기 작업이 비활성화되었습니다.",
|
||
},
|
||
mqRabbitMqMonitoring: {
|
||
title: "클러스터 모니터링",
|
||
loading: "불러오는 중...",
|
||
overviewTitle: "개요",
|
||
messagesReady: "준비된 메시지",
|
||
messagesUnacked: "미확인 메시지",
|
||
publishRate: "게시 비율",
|
||
deliverRate: "전달 비율",
|
||
ackRate: "확인 비율",
|
||
totalQueues: "큐",
|
||
totalExchanges: "익스체인지",
|
||
totalConnections: "연결",
|
||
totalChannels: "채널",
|
||
totalConsumers: "컨슈머",
|
||
nodesTitle: "노드",
|
||
nodeName: "노드",
|
||
status: "상태",
|
||
running: "실행 중",
|
||
stopped: "중지됨",
|
||
memory: "메모리",
|
||
diskFree: "여유 디스크",
|
||
fileDescriptors: "파일 디스크립터",
|
||
sockets: "소켓",
|
||
uptime: "가동 시간",
|
||
noNodes: "노드가 없습니다",
|
||
},
|
||
mqRocketmq: {
|
||
consumerGroupTitle: "컨슈머 그룹",
|
||
searchConsumerGroup: "컨슈머 그룹 검색",
|
||
connectionNotReady: "연결이 준비되지 않았습니다. 클러스터 정보를 새로고침하세요.",
|
||
tabSend: "메시지 보내기",
|
||
tabQuery: "메시지 쿼리",
|
||
noDlqTopics: "DLQ 토픽이 없습니다. 토픽 탭에서 DLQ 유형 필터를 활성화하고 새로고침하세요.",
|
||
topicFilterAll: "전체",
|
||
topicFilterBusiness: "비즈니스",
|
||
topicFilterDlq: "DLQ",
|
||
actionProduce: "생산",
|
||
actionConsume: "소비",
|
||
aclTitle: "접근 제어",
|
||
actionMessageQuery: "메시지 쿼리",
|
||
actionSendMessage: "메시지 보내기",
|
||
actionMore: "더보기",
|
||
actionDetailGroup: "상세",
|
||
actionResetOffset: "오프셋 재설정",
|
||
dlqConsumerGroup: "컨슈머 그룹",
|
||
dlqConsumerGroupPlaceholder: "컨슈머 그룹 (선택)",
|
||
dlqQueryByKey: "키로 쿼리",
|
||
viewDlqMessages: "DLQ 메시지 보기",
|
||
namesrvAddr: "NameServer",
|
||
},
|
||
mqAdmin: {
|
||
viewTenant: "테넌트 보기",
|
||
viewNamespace: "네임스페이스 보기",
|
||
viewTopic: "토픽 보기",
|
||
connectionMissing: "연결을 찾을 수 없습니다. 다시 연결한 후 시도하세요.",
|
||
writeDeniedReadOnly: "이 연결은 읽기 전용이며 쓰기 작업을 수행할 수 없습니다.",
|
||
readOnly: "읽기 전용",
|
||
allNamespaces: "모든 네임스페이스",
|
||
newNamespace: "새 네임스페이스",
|
||
namespace: "네임스페이스",
|
||
selectNamespaceToCreate: "만들려면 특정 네임스페이스를 선택하세요",
|
||
selectNamespaceToWrite: "이 작업을 수행하려면 특정 네임스페이스를 선택하세요",
|
||
tabTenants: "테넌트",
|
||
tabNamespaces: "네임스페이스",
|
||
tabTopics: "토픽",
|
||
tabSubscriptions: "구독",
|
||
tabConsumerGroups: "컨슈머 그룹",
|
||
tabMonitoring: "모니터링",
|
||
tabClients: "클라이언트",
|
||
tabMessages: "메시지",
|
||
tabBroker: "브로커",
|
||
tabCluster: "클러스터",
|
||
tabConsumers: "컨슈머",
|
||
tabProducers: "프로듀서",
|
||
tabDlq: "DLQ",
|
||
tabTrace: "추적",
|
||
tabAcl: "ACL",
|
||
tabPolicies: "정책",
|
||
tabPermissions: "권한",
|
||
tabRawApi: "원시 API",
|
||
},
|
||
mqMessages: {
|
||
title: "메시지 보내기",
|
||
clear: "지우기",
|
||
selectNamespaceOrTopicFirst: "먼저 네임스페이스나 토픽을 선택하세요",
|
||
readOnlyCannotSend: "이 연결은 읽기 전용이며 메시지를 보낼 수 없습니다",
|
||
selectTargetTopic: "대상 토픽을 선택하세요",
|
||
messageContentRequired: "메시지 내용은 필수입니다",
|
||
sendSuccess: "메시지 전송됨 — 파티션: {partition}, 오프셋: {offset}",
|
||
targetTopic: "대상 토픽",
|
||
topicLoading: "불러오는 중...",
|
||
topicSearchPlaceholder: "토픽 선택",
|
||
refreshTopicList: "토픽 목록 새로고침",
|
||
topicOptionWithPartitions: "{label} (파티션 {partitions}개)",
|
||
noTopicsAvailable: "사용 가능한 토픽이 없습니다",
|
||
topicSearchHint: "입력하여 목록을 필터링합니다. 토픽을 선택하면 쿼리가 실행됩니다. 회색으로 표시된 현재 토픽으로 다시 검색하려면 다시 클릭하세요.",
|
||
messageKey: "메시지 키",
|
||
messageTag: "메시지 태그",
|
||
exchange: "익스체인지",
|
||
exchangePlaceholder: "비움 = 기본 익스체인지",
|
||
exchangeHint: "설정하면 메시지가 큐로 직접 전달되는 대신 이 익스체인지로 게시됩니다.",
|
||
routingKey: "라우팅 키",
|
||
optional: "선택",
|
||
messageContent: "메시지 내용",
|
||
formatJson: "JSON 서식",
|
||
messageHeaders: "헤더",
|
||
headersPlaceholder: "key: value (한 줄에 하나)",
|
||
sending: "보내는 중...",
|
||
sendMessage: "메시지 보내기",
|
||
messageList: "메시지",
|
||
loadMessages: "메시지 불러오기",
|
||
loading: "불러오는 중...",
|
||
peekDefaultHint: "파티션 없이 처음부터 모든 파티션을 읽습니다.",
|
||
count: "개수",
|
||
advancedFilter: "고급 (파티션 / 오프셋)",
|
||
partition: "파티션",
|
||
partitionPlaceholderAll: "비움 = 전체",
|
||
offset: "오프셋",
|
||
offsetPlaceholderEarliest: "비움 = 처음",
|
||
offsetPlaceholderRequired: "필수",
|
||
startPosition: "읽기 시작 위치",
|
||
kafkaLatest: "최근 N개 메시지(기본값)",
|
||
kafkaEarliest: "가장 이른 메시지",
|
||
kafkaOffset: "오프셋부터 읽기",
|
||
timeOrder: "시간 순서",
|
||
newestFirst: "최신순",
|
||
oldestFirst: "오래된순",
|
||
kafkaLatestHint: "파티션마다 최대 N개의 후보를 읽은 뒤 토픽 전체에서 타임스탬프가 가장 최신인 N개를 선택합니다.",
|
||
kafkaEarliestHint: "선택한 각 파티션에서 가장 이른 메시지부터 읽습니다.",
|
||
kafkaOffsetHint: "지정한 오프셋부터 선택한 파티션(비워 두면 전체)을 읽습니다.",
|
||
messagesLoading: "메시지를 불러오는 중...",
|
||
noMessages: "메시지가 없습니다",
|
||
filterLoadedPlaceholder: "불러온 메시지 필터링",
|
||
filterLoadedCount: "{matched} / {loaded}",
|
||
noMatchingMessages: "이 필터와 일치하는 불러온 메시지가 없습니다",
|
||
peekIncomplete: "브로커가 스냅샷 읽기를 완료하지 못해 메시지 결과가 불완전합니다.",
|
||
selectTopicBeforeLoad: "메시지를 불러오기 전에 토픽을 선택하세요",
|
||
partitionMustBeNonNegativeInt: "파티션은 0 이상의 정수여야 하며, 모든 파티션은 비워 두세요",
|
||
offsetMustBeNonNegativeInt: "오프셋은 0 이상의 정수여야 하며, 처음은 비워 두세요",
|
||
offsetMustBeNonNegativeIntRequired: "오프셋은 0 이상의 정수여야 합니다",
|
||
offsetRequiredForOffset: "특정 오프셋부터 읽으려면 오프셋이 필요합니다",
|
||
metaPartition: "파티션 {partition}",
|
||
metaOffset: "오프셋 {offset}",
|
||
metaKey: "키 {key}",
|
||
jsonBodyPlaceholder: "{'{'}\"key\": \"value\"{'}'}",
|
||
queryTitle: "메시지 쿼리",
|
||
queryTabTopic: "토픽",
|
||
queryTabKey: "메시지 키",
|
||
queryTabMsgId: "메시지 ID",
|
||
queryTopicLabel: "토픽",
|
||
selectTopicPlaceholder: "토픽 선택",
|
||
noQueryResults: "조건과 일치하는 결과가 없습니다",
|
||
tableMessageId: "메시지 ID",
|
||
tableTag: "태그",
|
||
tableKey: "키",
|
||
tableStoreTime: "저장 시간",
|
||
tableOperation: "작업",
|
||
viewDetails: "보기",
|
||
messageDetails: "메시지 상세",
|
||
search: "검색",
|
||
messageQuery: "메시지 쿼리",
|
||
queryByMsgId: "메시지 ID로",
|
||
queryByKey: "키로",
|
||
queryByTopic: "토픽과 시간으로",
|
||
msgId: "메시지 ID",
|
||
msgIdPlaceholder: "예: 7F000001...",
|
||
msgIdRequired: "메시지 ID는 필수입니다",
|
||
queryKey: "메시지 키",
|
||
queryKeyPlaceholder: "비즈니스 키",
|
||
queryKeyRequired: "메시지 키는 필수입니다",
|
||
beginTime: "시작 시간",
|
||
endTime: "종료 시간",
|
||
maxNum: "최대 메시지 수",
|
||
invalidTimeRange: "시작 시간 또는 종료 시간이 유효하지 않습니다",
|
||
endTimeMustBeAfterBegin: "종료 시간은 시작 시간보다 늦어야 합니다",
|
||
query: "쿼리",
|
||
querying: "쿼리 중...",
|
||
messageOverview: "개요",
|
||
messageBody: "본문",
|
||
resendMessage: "재전송",
|
||
payloadCopied: "복사했습니다",
|
||
dlqConsumerGroupPlaceholder: "컨슈머 그룹 (선택)",
|
||
},
|
||
mqMonitoring: {
|
||
title: "모니터링",
|
||
autoRefresh: "자동 새로고침",
|
||
refreshInterval5s: "5초",
|
||
refreshInterval10s: "10초",
|
||
refreshInterval30s: "30초",
|
||
refreshInterval60s: "60초",
|
||
refreshing: "새로고침 중...",
|
||
refreshNow: "새로고침",
|
||
selectTopicFirst: "먼저 토픽을 선택하세요",
|
||
loadingStats: "모니터링 데이터를 불러오는 중...",
|
||
kafkaTopicOverview: "Kafka 토픽 개요",
|
||
partitionCount: "파티션",
|
||
replicationFactor: "복제 계수",
|
||
messageCount: "메시지",
|
||
logEndOffset: "로그 끝 오프셋",
|
||
offsetAndReplicaStatus: "오프셋과 복제본",
|
||
beginOffset: "시작 오프셋",
|
||
leaderCount: "리더",
|
||
isrHealthyPartitions: "ISR 정상",
|
||
noLeaderPartitions: "리더 없음",
|
||
kafkaPartitionDetails: "Kafka 파티션",
|
||
noKafkaPartitionMetrics: "Kafka 응답에 파티션 메트릭이 없습니다",
|
||
tablePartition: "파티션",
|
||
tableBeginOffset: "시작 오프셋",
|
||
tableLogEndOffset: "로그 끝 오프셋",
|
||
tableMessageCount: "메시지",
|
||
tableLeader: "리더",
|
||
tableReplicas: "복제본",
|
||
tableIsr: "ISR",
|
||
tableStatus: "상태",
|
||
statusNoLeader: "리더 없음",
|
||
statusIsrIncomplete: "ISR 불완전",
|
||
statusHealthy: "정상",
|
||
messagesLoading: "메시지를 불러오는 중...",
|
||
noMessages: "메시지가 없습니다",
|
||
messageRate: "메시지 비율",
|
||
inboundRate: "인바운드 비율",
|
||
outboundRate: "아웃바운드 비율",
|
||
inboundThroughput: "인바운드 처리량",
|
||
outboundThroughput: "아웃바운드 처리량",
|
||
rateTrend: "비율 추이",
|
||
backlogTrend: "백로그 추이",
|
||
consumerLag: "컨슈머 지연",
|
||
storageAndBacklog: "저장과 백로그",
|
||
storageSize: "저장 크기",
|
||
backlogSize: "백로그 크기",
|
||
backlogMessageCount: "백로그 메시지",
|
||
messageCounters: "메시지 카운터",
|
||
publishedMessages: "게시됨",
|
||
consumedMessages: "소비됨",
|
||
connectionStats: "연결",
|
||
subscriptionCount: "구독",
|
||
producerCount: "프로듀서",
|
||
partitionDetails: "파티션",
|
||
tableInbound: "수신",
|
||
tableOutbound: "송신",
|
||
tableInboundThroughput: "수신 처리량",
|
||
tableOutboundThroughput: "송신 처리량",
|
||
tableBacklogMessages: "백로그 메시지",
|
||
tableBacklogSize: "백로그 크기",
|
||
tableProducers: "프로듀서",
|
||
tableSubscriptions: "구독",
|
||
producers: "프로듀서",
|
||
subscriptions: "구독",
|
||
tableName: "이름",
|
||
tableRate: "비율",
|
||
tableAddress: "주소",
|
||
tableType: "유형",
|
||
tableBacklog: "백로그",
|
||
tableConsumers: "컨슈머",
|
||
noProducers: "프로듀서가 없습니다",
|
||
noSubscriptions: "구독이 없습니다",
|
||
noPartitionMetricsFromBroker: "브로커에서 파티션 메트릭이 없습니다",
|
||
nonPartitionedTopicNoDetails: "비파티션 토픽은 파티션 상세가 없습니다",
|
||
healthIndicators: "상태",
|
||
messageFlow: "메시지 흐름",
|
||
backlogStatus: "백로그",
|
||
producersLabel: "프로듀서",
|
||
subscriptionsLabel: "구독",
|
||
flowActive: "활성",
|
||
flowIdle: "유휴",
|
||
backlogNormal: "정상",
|
||
backlogHigh: "높음",
|
||
producerConnected: "연결됨",
|
||
producerDisconnected: "없음",
|
||
subscriptionActive: "활성",
|
||
subscriptionNone: "없음",
|
||
chartLegendIn: "수신",
|
||
chartLegendOut: "송신",
|
||
chartLegendMessages: "메시지",
|
||
chartLegendBytes: "바이트",
|
||
chartLegendConsumerLag: "컨슈머 지연",
|
||
chartAxisMsgPerSec: "msg/s",
|
||
chartAxisMsg: "msg",
|
||
chartAxisBytes: "bytes",
|
||
chartAxisMs: "ms",
|
||
metaPartition: "파티션 {partition}",
|
||
metaOffset: "오프셋 {offset}",
|
||
metaKey: "키 {key}",
|
||
rocketmqTopicOverview: "RocketMQ 토픽 개요",
|
||
rocketmqQueueDetails: "큐 오프셋 상세",
|
||
queueCount: "큐",
|
||
brokerCount: "브로커",
|
||
tableQueue: "큐",
|
||
tableBroker: "브로커",
|
||
noRocketMqQueueMetrics: "반환된 큐 메트릭이 없습니다",
|
||
},
|
||
mqTenants: {
|
||
title: "테넌트 관리",
|
||
createTenant: "테넌트 만들기",
|
||
notSupported: "이 메시징 시스템은 테넌트 관리를 지원하지 않습니다",
|
||
readOnly: "이 연결은 읽기 전용이며 쓰기 작업을 수행할 수 없습니다.",
|
||
loading: "불러오는 중...",
|
||
name: "이름",
|
||
adminRoles: "관리자 역할",
|
||
allowedClusters: "허용된 클러스터*",
|
||
actions: "작업",
|
||
none: "없음",
|
||
edit: "편집",
|
||
delete: "삭제",
|
||
createDialogTitle: "테넌트 만들기",
|
||
editDialogTitle: "테넌트 편집: {name}",
|
||
tenantName: "테넌트 이름*",
|
||
tenantNamePlaceholder: "예: my-tenant",
|
||
addRolePlaceholder: "역할 추가",
|
||
add: "추가",
|
||
selectClustersPlaceholder: "허용된 클러스터 선택",
|
||
noClustersDetectedPlaceholder: "감지된 클러스터 없음, 수동으로 추가",
|
||
clustersNotReturned: "연결이 클러스터 목록을 반환하지 않았습니다",
|
||
addClusterPlaceholder: "클러스터 수동 추가",
|
||
clustersRequiredHint: "최소 한 개의 허용된 클러스터를 선택하거나 추가하세요",
|
||
cancel: "취소",
|
||
create: "만들기",
|
||
save: "저장",
|
||
confirmDelete: '테넌트 "{name}"을(를) 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.',
|
||
tenantNameRequired: "테넌트 이름은 필수입니다",
|
||
allowedClustersRequired: "허용된 클러스터는 필수입니다",
|
||
},
|
||
mqNamespaces: {
|
||
title: "네임스페이스 관리",
|
||
createNamespace: "네임스페이스 만들기",
|
||
notSupported: "이 메시징 시스템은 네임스페이스 관리를 지원하지 않습니다",
|
||
selectTenantFirst: "먼저 테넌트를 선택하세요",
|
||
readOnly: "이 연결은 읽기 전용이며 쓰기 작업을 수행할 수 없습니다.",
|
||
loading: "불러오는 중...",
|
||
name: "이름",
|
||
tenant: "테넌트",
|
||
adminRoles: "관리자 역할",
|
||
actions: "작업",
|
||
none: "없음",
|
||
editRoles: "역할 편집",
|
||
delete: "삭제",
|
||
createDialogTitle: "네임스페이스 만들기",
|
||
namespaceName: "네임스페이스 이름*",
|
||
namespaceNamePlaceholder: "예: my-namespace",
|
||
cancel: "취소",
|
||
create: "만들기",
|
||
confirmDelete: '네임스페이스 "{name}"을(를) 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.',
|
||
namespaceNameRequired: "네임스페이스 이름은 필수입니다",
|
||
},
|
||
mqSubscriptions: {
|
||
title: "구독 관리",
|
||
createSubscription: "구독 만들기",
|
||
selectTopicFirst: "먼저 토픽을 선택하세요",
|
||
searchPlaceholder: "구독 이름 검색",
|
||
subscribedTopics: "구독한 토픽",
|
||
readOnly: "이 연결은 읽기 전용이며 쓰기 작업을 수행할 수 없습니다.",
|
||
loading: "불러오는 중...",
|
||
refresh: "새로고침",
|
||
refreshing: "새로고침 중...",
|
||
enriching: "온라인 상세 불러오는 중...",
|
||
truncatedHint: "처음 {count}개의 컨슈머 그룹만 표시합니다(상한). 검색 범위를 좁혀 주세요.",
|
||
enrichFailedHint: "온라인 멤버/구독 토픽 정보를 불러오지 못했습니다({error}). 빠른 목록만 표시합니다.",
|
||
noSubscriptions: "이 토픽에 구독이 없습니다",
|
||
noConsumerGroups: "컨슈머 그룹이 없습니다",
|
||
noMatches: "일치하는 컨슈머 그룹이 없습니다",
|
||
backlogPartialFailed: "{count}개 토픽의 백로그를 불러오지 못했습니다: {error}",
|
||
viewDetail: "상세",
|
||
editConfig: "구성",
|
||
save: "저장",
|
||
consumerDetailTitle: "컨슈머 그룹 상세: {name}",
|
||
consumerConfigTitle: "컨슈머 그룹 구성: {name}",
|
||
consumerOverview: "개요",
|
||
consumerTerminals: "온라인 터미널",
|
||
consumerConsumeDetail: "소비 상세",
|
||
noOnlineConsumers: "온라인 컨슈머가 없습니다",
|
||
noConsumeDetail: "소비 상세가 없습니다",
|
||
noQueueConsumeProgress: "큐 소비 진행 정보가 없습니다",
|
||
operationTopic: "토픽",
|
||
consumeDelay: "적체",
|
||
invalidTopicScope: "잘못된 토픽 범위",
|
||
lastConsumeTime: "마지막 소비 시간",
|
||
broker: "broker",
|
||
queue: "queue",
|
||
consumerClient: "consumerClient",
|
||
brokerOffset: "brokerOffset",
|
||
consumerOffset: "consumerOffset",
|
||
diffTotal: "diffTotal",
|
||
lastTimestamp: "lastTimestamp",
|
||
consumeEnable: "소비 활성화",
|
||
consumeBroadcastEnable: "브로드캐스트 소비 활성화",
|
||
consumeFromMinEnable: "최소 오프셋부터 소비",
|
||
consumeMessageOrderly: "순서 보장 소비",
|
||
retryQueueNums: "재시도 큐 수",
|
||
retryMaxTimes: "최대 재시도 횟수",
|
||
brokerId: "브로커 ID",
|
||
whichBrokerWhenConsumeSlowly: "느린 소비 브로커 ID",
|
||
subscriptionName: "구독 이름",
|
||
type: "유형",
|
||
mode: "모드",
|
||
typeFilter: "유형 필터",
|
||
rocketmqGroupType: {
|
||
normal: "일반",
|
||
fifo: "순서 보장",
|
||
system: "시스템",
|
||
unknown: "알 수 없음",
|
||
},
|
||
rocketmqGroupMode: {
|
||
clustering: "클러스터",
|
||
broadcasting: "브로드캐스트",
|
||
},
|
||
backlog: "백로그",
|
||
consumeRate: "소비 비율",
|
||
consumers: "컨슈머",
|
||
actions: "작업",
|
||
consumerCount: "컨슈머 {count}개",
|
||
msgRate: "{rate} msg/s",
|
||
resetCursor: "커서 재설정",
|
||
skipMessages: "메시지 건너뛰기",
|
||
clearBacklog: "백로그 비우기",
|
||
peek: "메시지 보기",
|
||
expireMessages: "메시지 만료",
|
||
delete: "삭제",
|
||
createDialogTitle: "구독 만들기",
|
||
topic: "토픽",
|
||
subscriptionNameLabel: "구독 이름*",
|
||
subscriptionNamePlaceholder: "예: my-subscription",
|
||
startPosition: "시작 위치",
|
||
startFromEarliest: "가장 오래된 메시지부터 (Earliest)",
|
||
startFromLatest: "가장 최신 메시지부터 (Latest)",
|
||
resetDialogTitle: "커서 재설정: {name}",
|
||
resetTo: "재설정 위치",
|
||
earliest: "가장 오래된 메시지 (Earliest)",
|
||
latest: "가장 최신 메시지 (Latest)",
|
||
timestamp: "특정 타임스탬프",
|
||
timestampMs: "타임스탬프 (ms)",
|
||
currentTime: "현재 시간: {time}",
|
||
reset: "재설정",
|
||
skipDialogTitle: "메시지 건너뛰기: {name}",
|
||
skipMode: "건너뛰기 모드",
|
||
skipCount: "지정한 수 건너뛰기",
|
||
skipAll: "모든 백로그 건너뛰기",
|
||
skipCountLabel: "건너뛸 수",
|
||
skip: "건너뛰기",
|
||
peekDialogTitle: "메시지 보기: {name}",
|
||
count: "개수",
|
||
noPeekMessages: "볼 메시지가 없습니다",
|
||
close: "닫기",
|
||
expireDialogTitle: "메시지 만료: {name}",
|
||
expireSeconds: "만료 시간 (초)",
|
||
expireHint: "{seconds}초보다 오래된 모든 메시지를 삭제합니다",
|
||
expire: "만료",
|
||
cancel: "취소",
|
||
create: "만들기",
|
||
confirmDelete: '구독 "{name}"을(를) 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.',
|
||
confirmClearBacklog: '구독 "{name}"의 모든 백로그 메시지를 비우시겠습니까?',
|
||
subscriptionNameRequired: "구독 이름은 필수입니다",
|
||
peekMessageKey: "키={key}",
|
||
},
|
||
mqKafkaConsumerGroups: {
|
||
title: "컨슈머 그룹",
|
||
searchPlaceholder: "그룹 또는 토픽 검색",
|
||
refresh: "새로 고침",
|
||
refreshing: "새로 고치는 중...",
|
||
loading: "컨슈머 그룹을 불러오는 중...",
|
||
empty: "컨슈머 그룹이 없습니다",
|
||
noMatches: "일치하는 컨슈머 그룹이 없습니다",
|
||
groupId: "그룹 ID",
|
||
state: "상태",
|
||
members: "멤버",
|
||
topics: "토픽",
|
||
totalLag: "총 지연",
|
||
partialData: "일부 지표를 사용할 수 없습니다",
|
||
partitionDetail: "파티션 지연 상세",
|
||
noCommittedOffsets: "커밋된 오프셋 또는 할당된 파티션이 없습니다",
|
||
topic: "토픽",
|
||
openTopicSubscriptions: "{topic} 구독 열기",
|
||
partition: "파티션",
|
||
committedOffset: "커밋된 오프셋",
|
||
logEndOffset: "로그 끝 오프셋",
|
||
lag: "지연",
|
||
},
|
||
mqClients: {
|
||
unloadTopicUnsupportedKafka: "Kafka는 토픽 언로드를 지원하지 않습니다",
|
||
title: "프로듀서 / 컨슈머",
|
||
unloadTopic: "토픽 언로드",
|
||
unloading: "언로드 중...",
|
||
refresh: "새로고침",
|
||
refreshing: "새로고침 중...",
|
||
selectTopicFirst: "먼저 토픽을 선택하세요",
|
||
rocketmqClusterHint: "브로커의 모든 온라인 프로듀서와 컨슈머 그룹 터미널을 표시합니다. 토픽 범위의 클라이언트 상세는 토픽을 선택하세요.",
|
||
confirmUnload: "이 토픽을 언로드하시겠습니까? 활성 프로듀서와 컨슈머가 다시 연결됩니다.",
|
||
aggregateTopic: "토픽 집계",
|
||
kafkaPartitionStatus: "Kafka 파티션 상태",
|
||
partitionCount: "파티션 {count}개",
|
||
partition: "파티션",
|
||
beginOffset: "시작 오프셋",
|
||
latestOffset: "최신 오프셋",
|
||
messageCount: "메시지",
|
||
leader: "리더",
|
||
replicas: "복제본",
|
||
isr: "ISR",
|
||
partitionClients: "파티션 클라이언트",
|
||
inboundRate: "인바운드 비율",
|
||
outboundRate: "아웃바운드 비율",
|
||
producers: "프로듀서",
|
||
subscriptions: "구독",
|
||
consumers: "컨슈머",
|
||
activeProducers: "활성 프로듀서",
|
||
noActiveProducers: "활성 프로듀서가 없습니다",
|
||
name: "이름",
|
||
id: "ID",
|
||
address: "주소",
|
||
version: "버전",
|
||
rate: "비율",
|
||
throughput: "처리량",
|
||
rateValue: "{value} msg/s",
|
||
activeConsumers: "활성 컨슈머",
|
||
noSubscriptions: "이 토픽에는 구독이 없습니다",
|
||
noConsumersOnPartition: "이 파티션 구독에 활성 컨슈머가 없습니다",
|
||
noConsumersOnSubscription: "이 구독에 활성 컨슈머가 없습니다",
|
||
permits: "허가",
|
||
},
|
||
mqPolicies: {
|
||
title: "정책 관리",
|
||
refresh: "새로고침",
|
||
refreshing: "새로고침 중...",
|
||
selectTopicFirst: "먼저 토픽을 선택하세요",
|
||
selectNamespaceOrTopic: "네임스페이스 또는 토픽을 선택하세요",
|
||
readOnly: "이 연결은 읽기 전용이며 쓰기 작업을 수행할 수 없습니다.",
|
||
readonlyHint: "이 연결은 읽기 전용이며 정책 편집이 비활성화되었습니다.",
|
||
publishRate: "게시 비율 제한",
|
||
msgsPerSecond: "초당 메시지",
|
||
bytesPerSecond: "초당 바이트",
|
||
save: "저장",
|
||
dispatchRate: "디스패치 비율 제한",
|
||
msgsPerPeriod: "기간당 메시지",
|
||
bytesPerPeriod: "기간당 바이트",
|
||
periodSeconds: "기간 (초)",
|
||
subscribeRate: "구독 비율 제한",
|
||
msgsPerConsumerPerPeriod: "컨슈머당/기간당 메시지",
|
||
backlogQuota: "백로그 할당량",
|
||
sizeLimitBytes: "크기 제한 (바이트)",
|
||
timeLimitSeconds: "시간 제한 (초)",
|
||
policy: "정책",
|
||
type: "유형",
|
||
backlogPolicyProducerRequestHold: "프로듀서 요청 보류",
|
||
backlogPolicyProducerException: "예외로 거부",
|
||
backlogPolicyConsumerBacklogEviction: "컨슈머 백로그 제거",
|
||
retention: "메시지 보존",
|
||
retentionTimeMinutes: "보존 시간 (분)",
|
||
retentionSizeMb: "보존 크기 (MB)",
|
||
effectivePolicies: "유효 정책",
|
||
savedNotice: "{policy} 저장됨",
|
||
},
|
||
mqPermissions: {
|
||
title: "권한",
|
||
refresh: "새로고침",
|
||
refreshing: "새로고침 중...",
|
||
selectNamespaceOrTopic: "먼저 네임스페이스나 토픽을 선택하세요",
|
||
readOnly: "이 연결은 읽기 전용이며 쓰기 작업을 수행할 수 없습니다.",
|
||
readonlyHint: "이 연결은 읽기 전용이며 부여와 회수가 비활성화되었습니다.",
|
||
grantRole: "역할 부여",
|
||
roleName: "역할 이름",
|
||
roleNamePlaceholder: "예: app-producer",
|
||
actions: "작업",
|
||
grant: "부여",
|
||
currentPermissions: "현재 권한",
|
||
role: "역할",
|
||
operations: "작업",
|
||
token: "토큰",
|
||
revoke: "회수",
|
||
noPermissions: "권한 기록이 없습니다",
|
||
clientTokenTitle: "클라이언트 토큰: {role}",
|
||
missingSigningKeyTitle: "토큰 서명 키가 구성되지 않았습니다",
|
||
missingSigningKeyMessage: "이 MQ 연결에는 브로커 토큰 서명 키가 구성되지 않아 클라이언트 토큰을 발급할 수 없습니다.",
|
||
missingSigningKeyDetail: '연결을 편집하고 "브로커 토큰 서명"을 HS256 SECRET 또는 RS256 PRIVATE로 설정한 후 토큰을 생성하기 전에 서명 키를 제공하세요.',
|
||
tokenShowOnceWarning: "토큰은 한 번만 표시됩니다. 즉시 복사하여 저장하세요.",
|
||
copyToken: "토큰 복사",
|
||
issueNewToken: "새 토큰 발급",
|
||
neverExpires: "만료 없음",
|
||
expiryDays: "만료 (일)",
|
||
note: "메모",
|
||
notePlaceholder: "예: rt-erp-server용",
|
||
issuing: "발급 중...",
|
||
generateToken: "토큰 생성",
|
||
tokenRevokeHint: "역할 권한을 회수해도 발급된 JWT가 즉시 무효화되지 않습니다. 만료를 기다리거나 브로커 서명 키를 교체하세요.",
|
||
issueRecords: "발급 기록",
|
||
time: "시간",
|
||
algorithm: "알고리즘",
|
||
expires: "만료",
|
||
fingerprint: "지문",
|
||
noteColumn: "메모",
|
||
unlimited: "영구",
|
||
loading: "불러오는 중...",
|
||
noIssueRecords: "발급 기록이 없습니다",
|
||
close: "닫기",
|
||
kafkaAuthorizerNotConfigured: "이 Kafka 클러스터에는 인증자가 구성되지 않았습니다. ACL 지원을 위해 브로커 구성에 authorizer.class.name을 추가하세요.",
|
||
kafkaAuthorizerDisabled: "이 Kafka 클러스터에는 인증자가 활성화되지 않았습니다. 권한을 부여하려면 브로커 구성에서 인증자를 활성화하세요.",
|
||
roleNameRequired: "역할 이름은 필수입니다",
|
||
selectAtLeastOneAction: "최소 한 개의 작업을 선택하세요",
|
||
grantedRole: "{role} 부여됨",
|
||
confirmRevoke: '역할 "{role}"의 권한을 회수하시겠습니까?',
|
||
revokedRole: "{role} 회수됨",
|
||
roleNameEmpty: "역할 이름은 비워둘 수 없습니다",
|
||
expiryMustBePositive: "만료는 0일보다 커야 합니다",
|
||
},
|
||
mqBroker: {
|
||
title: "브로커 클러스터",
|
||
autoRefresh: "자동 새로고침",
|
||
refreshInterval5s: "5초",
|
||
refreshInterval10s: "10초",
|
||
refreshInterval30s: "30초",
|
||
refreshInterval60s: "60초",
|
||
refreshing: "새로고침 중...",
|
||
refreshNow: "지금 새로고침",
|
||
loading: "불러오는 중...",
|
||
clusterOverview: "클러스터 개요",
|
||
clusterId: "클러스터 ID",
|
||
unknown: "알 수 없음",
|
||
brokerCount: "브로커",
|
||
controller: "컨트롤러",
|
||
controllerNode: "노드 {id} · {host}",
|
||
brokerNodes: "브로커 노드",
|
||
brokerName: "브로커 이름",
|
||
brokerEndpoints: "브로커 엔드포인트",
|
||
nodeId: "노드 ID",
|
||
host: "호스트",
|
||
port: "포트",
|
||
rack: "랙",
|
||
role: "역할",
|
||
roleController: "컨트롤러",
|
||
roleFollower: "팔로워",
|
||
roleMaster: "마스터",
|
||
roleSlave: "슬레이브",
|
||
noBrokerNodes: "브로커 노드 정보가 없습니다",
|
||
clusterTitle: "클러스터",
|
||
},
|
||
mqDlq: {
|
||
title: "데드 레터 큐",
|
||
refresh: "새로고침",
|
||
refreshing: "새로고침 중...",
|
||
loading: "불러오는 중...",
|
||
selectContext: "먼저 네임스페이스 컨텍스트를 선택하세요",
|
||
selectTopic: "DLQ 토픽을 선택하세요",
|
||
topic: "DLQ 토픽",
|
||
consumerGroup: "컨슈머 그룹",
|
||
groupPlaceholder: "선택 peek 그룹",
|
||
queryByKey: "메시지 키로 쿼리",
|
||
queryKey: "메시지 키",
|
||
queryKeyPlaceholder: "검색할 키",
|
||
loadMessages: "메시지 불러오기",
|
||
loadingMessages: "메시지를 불러오는 중...",
|
||
noDlqTopics: "DLQ 토픽이 없습니다. 토픽 탭에서 DLQ 유형 필터를 활성화하여 나열하세요.",
|
||
noMessages: "메시지가 없습니다",
|
||
},
|
||
mqTrace: {
|
||
title: "메시지 추적",
|
||
msgId: "메시지 ID",
|
||
msgIdPlaceholder: "원본 메시지 ID",
|
||
msgIdRequired: "메시지 ID는 필수입니다",
|
||
queryKeyRequired: "메시지 키는 필수입니다",
|
||
selectTopicBeforeQuery: "추적을 쿼리하기 전에 토픽을 선택하세요",
|
||
traceTopic: "추적 토픽",
|
||
traceTopicPlaceholder: "RMQ_SYS_TRACE_TOPIC",
|
||
query: "추적 쿼리",
|
||
querying: "쿼리 중...",
|
||
noTrace: "추적 기록이 없습니다",
|
||
searchHint: "먼저 메시지를 검색한 후 추적 보기를 클릭하세요",
|
||
viewTrace: "추적 보기",
|
||
detailTitle: "메시지 추적 상세",
|
||
traceTopicRouteMissing:
|
||
"추적 토픽이 NameServer에 라우트 정보가 없습니다 (CODE: 17).\n\n일반적인 원인:\n1. Broker 추적이 비활성화됨: broker.conf에서 traceTopicEnable=true를 설정하고 Broker를 다시 시작\n2. Producer/Consumer 추적이 비활성화됨: setEnableTrace(true) 호출\n3. 사용자 지정 추적 토픽 사용: 위에서 올바른 추적 토픽을 선택하세요",
|
||
typePub: "Pub",
|
||
typeSubBefore: "SubBefore",
|
||
typeSubAfter: "SubAfter",
|
||
typeEndTransaction: "EndTransaction",
|
||
typeUnknown: "알 수 없음",
|
||
statusSuccess: "성공",
|
||
statusFail: "실패",
|
||
fieldRegionId: "Region",
|
||
fieldGroup: "Group",
|
||
fieldTopic: "Topic",
|
||
fieldMsgId: "MsgId",
|
||
fieldTags: "Tags",
|
||
fieldKeys: "Keys",
|
||
fieldStoreHost: "Store Host",
|
||
fieldClientHost: "Client Host",
|
||
fieldBodyLength: "Body Length",
|
||
fieldCostTime: "소요 시간",
|
||
fieldMsgType: "메시지 유형",
|
||
fieldOffsetMsgId: "Offset MsgId",
|
||
fieldRequestId: "Request ID",
|
||
fieldRetryTimes: "재시도",
|
||
fieldContextCode: "Context Code",
|
||
rawPayload: "원본 추적",
|
||
},
|
||
mqRaw: {
|
||
title: "원시 API",
|
||
sending: "보내는 중...",
|
||
sendRequest: "요청 보내기",
|
||
readOnlyHint: "이 연결은 읽기 전용이며 GET, HEAD, OPTIONS 요청만 허용됩니다.",
|
||
commonEndpoints: "공통 엔드포인트",
|
||
fillFromSelection: "현재 선택에서 요청 채우기",
|
||
expand: "펼치기",
|
||
collapse: "접기",
|
||
method: "메서드",
|
||
path: "경로",
|
||
pathPlaceholder: "/admin/v2/...",
|
||
queryParams: "쿼리 매개변수",
|
||
queryPlaceholder: "key=value, 한 줄에 하나",
|
||
jsonBody: "JSON 본문",
|
||
format: "서식",
|
||
bodyPlaceholder: "예: {'{'}\"key\":\"value\"{'}'}",
|
||
response: "응답",
|
||
textResponse: "텍스트 응답",
|
||
noRequestYet: "아직 보낸 요청이 없습니다",
|
||
readOnly: "이 연결은 읽기 전용이며 쓰기 작업을 수행할 수 없습니다.",
|
||
pathRequired: "요청 경로는 필수입니다",
|
||
jsonBodyInvalid: "잘못된 JSON 본문: {error}",
|
||
presetBrokerVersion: "브로커 버전",
|
||
presetBrokerVersionDesc: "브로커 버전 문자열",
|
||
presetClusters: "클러스터 목록",
|
||
presetClustersDesc: "구성된 Pulsar 클러스터 목록",
|
||
presetTenant: "테넌트 상세",
|
||
presetTenantDesc: "adminRoles / allowedClusters 보기",
|
||
presetNamespacePolicies: "네임스페이스 정책",
|
||
presetNamespacePoliciesDesc: "원시 네임스페이스 정책 구조",
|
||
presetBundles: "번들 목록",
|
||
presetBundlesDesc: "네임스페이스 번들 분포",
|
||
presetTopicInternalStats: "토픽 내부 통계",
|
||
presetTopicInternalStatsDesc: "원장 / 커서 / 백로그 상세",
|
||
presetPartitionedStats: "파티션 메트릭",
|
||
presetPartitionedStatsDesc: "파티션별 비율, 프로듀서, 컨슈머",
|
||
presetSchema: "최신 스키마",
|
||
presetSchemaDesc: "현재 토픽 스키마 정의",
|
||
},
|
||
nacos: {
|
||
openConsole: "콘솔 열기",
|
||
consoleUrlMissing: "먼저 Nacos 웹 콘솔 URL을 구성하세요.",
|
||
consoleOpenFailed: "Nacos 콘솔을 열지 못했습니다.",
|
||
enterZenMode: "작업 공간 확장",
|
||
exitZenMode: "확장 작업 공간 종료",
|
||
dashboard: "대시보드",
|
||
dashboardTitle: "운영 대시보드",
|
||
dashboardUpdatedAt: "{time}에 업데이트됨",
|
||
dashboardAutoRefresh: "자동 새로고침",
|
||
dashboardOff: "꺼짐",
|
||
dashboardNamespaces: "네임스페이스",
|
||
dashboardConfigs: "구성",
|
||
dashboardServices: "서비스",
|
||
dashboardInstances: "인스턴스",
|
||
dashboardClients: "클라이언트",
|
||
dashboardConnections: "연결 {count}개",
|
||
dashboardNodes: "정상 노드",
|
||
dashboardCpu: "CPU",
|
||
dashboardMemory: "메모리",
|
||
dashboardLoad: "부하 {value}",
|
||
dashboardCountsChart: "서비스 디스커버리",
|
||
dashboardResourcesChart: "리소스 사용률",
|
||
dashboardClusterNodes: "클러스터 노드",
|
||
dashboardSite: "사이트",
|
||
dashboardLastRefresh: "마지막 새로고침",
|
||
dashboardNoNodes: "클러스터 노드 상세를 사용할 수 없습니다",
|
||
dashboardPartial: "대시보드 소스 {count}개를 사용할 수 없습니다",
|
||
dashboardMemoryUsed: "힙 / 메모리 사용",
|
||
dashboardMemoryMax: "최대 {value}",
|
||
dashboardRss: "RSS 메모리",
|
||
dashboardVms: "가상 메모리",
|
||
dashboardJvmThreads: "JVM 데몬 스레드",
|
||
dashboardGcPauses: "GC 일시 중지",
|
||
dashboardTrafficSection: "요청 트래픽",
|
||
dashboardRequestRateChart: "초당 HTTP / gRPC 요청",
|
||
dashboardLatencyChart: "요청 대기 시간",
|
||
dashboardHttpQps: "HTTP QPS",
|
||
dashboardGrpcQps: "gRPC QPS",
|
||
dashboardHttpAverage: "HTTP 평균",
|
||
dashboardHttpP50: "HTTP P50",
|
||
dashboardHttpP95: "HTTP P95",
|
||
dashboardHttpP99: "HTTP P99",
|
||
dashboardGrpcAverage: "gRPC 평균",
|
||
dashboardGrpcP50: "gRPC P50",
|
||
dashboardGrpcP95: "gRPC P95",
|
||
dashboardGrpcP99: "gRPC P99",
|
||
dashboardReliabilitySection: "신뢰성",
|
||
dashboardErrorRateChart: "요청 오류 비율",
|
||
dashboardExecutorChart: "gRPC 실행자",
|
||
dashboardHttpErrors: "HTTP 오류",
|
||
dashboardGrpcErrors: "gRPC 오류",
|
||
dashboardExecutorPool: "풀 크기",
|
||
dashboardExecutorActive: "활성",
|
||
dashboardExecutorQueue: "대기 중",
|
||
dashboardConfigSection: "구성 센터",
|
||
dashboardConfigRateChart: "초당 구성 작업",
|
||
dashboardConfigStateChart: "리스너와 대기 작업",
|
||
dashboardConfigGets: "가져오기",
|
||
dashboardConfigPublishes: "게시",
|
||
dashboardLongPolling: "롱 폴링",
|
||
dashboardListenerClients: "리스너 클라이언트",
|
||
dashboardListenerKeys: "리스너 키",
|
||
dashboardNotifyTasks: "알림 작업",
|
||
dashboardNotifyClientTasks: "클라이언트 알림 작업",
|
||
dashboardDumpTasks: "덤프 작업",
|
||
dashboardNamingSection: "서비스 디스커버리",
|
||
dashboardNamingStateChart: "서비스, 인스턴스, 클라이언트",
|
||
dashboardPushRateChart: "초당 푸시",
|
||
dashboardPushDetailChart: "푸시 대기 시간과 대기 작업",
|
||
dashboardPushAverage: "평균 대기 시간",
|
||
dashboardPushMaximum: "최대 대기 시간",
|
||
dashboardPushPending: "대기 작업",
|
||
dashboardSubscribers: "구독자",
|
||
dashboardPushes: "푸시",
|
||
dashboardFailedPushes: "실패한 푸시",
|
||
dashboardEmptyPushes: "빈 푸시",
|
||
configs: "구성",
|
||
services: "서비스",
|
||
raw: "원시",
|
||
namespace: "네임스페이스",
|
||
createNamespace: "네임스페이스 만들기",
|
||
editNamespace: "네임스페이스 편집",
|
||
deleteNamespace: "네임스페이스 삭제",
|
||
deleteNamespaceDescription: "네임스페이스 {name}({id})을 삭제하시겠습니까? 구성과 서비스에 더 이상 접근하지 못할 수 있으며 이 작업은 되돌릴 수 없습니다.",
|
||
creatingNamespace: "만드는 중...",
|
||
updatingNamespace: "업데이트 중...",
|
||
deletingNamespace: "삭제 중...",
|
||
namespaceCreated: '네임스페이스 "{name}" 생성됨',
|
||
namespaceUpdated: '네임스페이스 "{name}" 업데이트됨',
|
||
namespaceDeleted: '네임스페이스 "{name}" 삭제됨',
|
||
namespaceId: "네임스페이스 ID",
|
||
namespaceIdPlaceholder: "DBX가 UUID를 자동 생성하도록 비워 두세요",
|
||
namespaceName: "네임스페이스 이름",
|
||
namespaceNamePlaceholder: "네임스페이스 이름 입력",
|
||
namespaceDesc: "설명",
|
||
namespaceDescPlaceholder: "기본값은 네임스페이스 이름",
|
||
dataId: "데이터 ID",
|
||
group: "그룹",
|
||
format: "형식",
|
||
content: "내용",
|
||
tags: "태그",
|
||
application: "애플리케이션",
|
||
description: "설명",
|
||
advanced: "고급",
|
||
collapse: "접기",
|
||
configIdentity: "구성 식별자",
|
||
newConfigDraft: "새 구성",
|
||
draft: "초안",
|
||
unsaved: "저장되지 않음",
|
||
published: "게시됨",
|
||
readOnlyState: "읽기 전용",
|
||
load: "불러오기",
|
||
save: "저장",
|
||
saveAs: "다른 이름으로 저장",
|
||
saving: "저장 중...",
|
||
saved: "구성을 저장했습니다",
|
||
createdAndLoaded: "{dataId} 생성 후 불러옴",
|
||
savedAndLoaded: "{dataId} 저장 후 새로고침",
|
||
deleted: "구성을 삭제했습니다",
|
||
delete: "삭제",
|
||
copy: "복사",
|
||
copied: "복사했습니다",
|
||
copyVerifyFailed: "쓰기 후 클립보드 검증 실패",
|
||
export: "내보내기",
|
||
exported: "내보냈습니다",
|
||
exportedTo: "{path}로 내보냈습니다",
|
||
exportFailed: "내보내기 실패: {message}",
|
||
contentSearch: "전문 검색",
|
||
contentSearchTitle: "Nacos 구성 전체 전문 검색",
|
||
contentSearchDescription: "현재 게시된 구성 내용에 대해 대소문자 구분 리터럴 검색을 실행합니다. 기록 버전은 검색되지 않습니다.",
|
||
contentSearchPlaceholder: "데이터베이스 URL, 계정 또는 모든 구성 조각",
|
||
search: "검색",
|
||
cancel: "취소",
|
||
currentNamespace: "현재 네임스페이스",
|
||
allNamespaces: "이 연결의 모든 네임스페이스",
|
||
allNamespacesSearchWarning: "모든 네임스페이스를 검색하면 많은 구성을 열거할 수 있습니다. Nacos 2.x와 r-nacos에서 느릴 수 있으며 서버 부하가 증가합니다.",
|
||
scannedCount: "{count}개 스캔",
|
||
matchCount: "{count}개 일치",
|
||
incompleteResult: "결과가 불완전할 수 있습니다",
|
||
lineNumber: "{line}행",
|
||
noContentMatches: "이 내용을 포함한 구성이 없습니다",
|
||
contentSearchEmptyHint: "검색하려면 키워드를 입력하세요. 키워드, 내용, 스니펫은 디스크나 로그에 저장되지 않습니다.",
|
||
searchResults: "검색 결과",
|
||
searchResultsRetainedHint: "내용 영역에서 결과를 여세요. 이 결과 집합은 상단 도구 모음의 검색 결과에서 계속 사용할 수 있습니다.",
|
||
openedSearchResult: "열림",
|
||
exportSearchResults: "결과 내보내기",
|
||
clearSearchResults: "검색 결과 지우기",
|
||
searchResultsExported: "검색 결과를 내보냈습니다",
|
||
searchResultsExportedTo: "검색 결과를 {path}로 내보냈습니다",
|
||
batchExport: "일괄 내보내기",
|
||
batchImport: "일괄 가져오기",
|
||
copyToNamespace: "구성 동기화",
|
||
batchDelete: "일괄 삭제",
|
||
batchDeleteTitle: "선택한 Nacos 구성 삭제",
|
||
batchDeleteConfirm: "선택한 구성 {count}개를 삭제할까요? 이 작업은 되돌릴 수 없습니다.",
|
||
batchDeleteSuccess: "구성 {count}개를 삭제했습니다",
|
||
batchDeletePartial: "구성 {deleted}개를 삭제했고 {failed}개는 실패했습니다.",
|
||
batchDeleteInterrupted: "일괄 삭제가 중지되었습니다. 구성 {deleted}개를 삭제했습니다.",
|
||
configPageSize: "페이지당 항목",
|
||
selectedCount: "{count}개 선택됨",
|
||
retryConnectionInfo: "연결 정보 프로브 다시 시도",
|
||
resizeColumn: "드래그하여 열 크기 조정",
|
||
visibleColumns: "표시 열",
|
||
configListGroup: "그룹",
|
||
configListApplication: "애플리케이션",
|
||
configListFormat: "형식",
|
||
selectCurrentPage: "현재 페이지 선택",
|
||
selectConfigForBatch: "구성 {dataId} 선택",
|
||
batchExportTitle: "Nacos 구성 일괄 내보내기",
|
||
batchExportDescription: "Nacos 콘솔 호환 ZIP을 만듭니다. 복호화된 평문 구성이 포함되므로 안전하게 보관해야 합니다.",
|
||
batchImportTitle: "Nacos 구성 일괄 가져오기",
|
||
batchImportDescription: "아카이브를 안전하게 파싱하고 각 항목을 현재 네임스페이스에 게시하기 전에 충돌을 미리 봅니다.",
|
||
batchCopyTitle: "구성을 다른 네임스페이스로 동기화",
|
||
batchCopyDescription: "동기화는 단방향 복사 의미를 사용하며 소스 구성을 삭제하거나 변경하지 않습니다. 대상 충돌은 선택한 정책을 사용합니다.",
|
||
exportScope: "구성 범위",
|
||
selectedConfigs: "선택한 구성 ({count})",
|
||
filteredConfigs: "현재 필터와 일치하는 전체 (추정 {count})",
|
||
namespaceAllConfigs: "이 네임스페이스의 모든 구성",
|
||
importArchive: "Nacos ZIP 아카이브",
|
||
noArchiveSelected: "선택한 ZIP이 없습니다",
|
||
chooseZip: "ZIP 선택",
|
||
importSensitiveWarning: "호환 ZIP에는 평문 데이터베이스 비밀번호, 키 및 기타 비밀이 포함될 수 있습니다. 신뢰할 수 있는 아카이브만 가져오세요.",
|
||
targetConnection: "대상 연결",
|
||
chooseTargetConnection: "대상 Nacos 연결 선택",
|
||
noTargetConnections: "쓰기 가능한 Nacos 연결이 없습니다. 연결을 추가하거나 대상 연결의 읽기 전용 설정을 제거하세요.",
|
||
targetNamespace: "대상 네임스페이스",
|
||
chooseTargetNamespace: "다른 네임스페이스 선택",
|
||
targetGroup: "대상 그룹(선택 사항)",
|
||
targetGroupPlaceholder: "원본 그룹과 동일",
|
||
targetDataIds: "대상 Data ID(선택 사항)",
|
||
targetDataIdsHint: "선택한 구성을 개별적으로 이름 변경할 수 있습니다. 비워 두면 원본 Data ID를 유지합니다.",
|
||
copyKeepsSource: "동기화는 단방향 복사 의미를 사용합니다. 소스 네임스페이스 구성은 변경되지 않습니다.",
|
||
conflictPolicy: "충돌 정책",
|
||
policyABORT: "충돌 시 중단",
|
||
policyABORTHint: "미리보기에서 충돌을 발견하면 아무것도 쓰지 않습니다",
|
||
policySKIP: "충돌 건너뛰기",
|
||
policySKIPHint: "대상에 없는 구성만 만듭니다",
|
||
policyOVERWRITE: "대상 덮어쓰기",
|
||
policyOVERWRITEHint: "같은 키의 대상 구성을 소스로 교체합니다",
|
||
overwriteWarning: "덮어쓰기는 게시된 대상 구성을 변경하며 한 번 더 확인이 필요합니다.",
|
||
overwriteConfirm: "대상 네임스페이스의 모든 충돌 구성을 덮어쓰시겠습니까? 이 작업은 자동으로 롤백할 수 없습니다.",
|
||
preview: "미리보기",
|
||
apply: "적용",
|
||
exportZip: "ZIP 내보내기",
|
||
previewTotal: "전체 {count}",
|
||
previewCreated: "새 항목 {count}",
|
||
previewConflicts: "충돌 {count}",
|
||
previewInvalid: "잘못됨 {count}",
|
||
previewExpired: "미리보기가 만료되었습니다. 미리보기를 다시 실행하세요.",
|
||
batchFinished: "동기화 완료: {written}개 쓰기",
|
||
batchAborted: "동기화 실행 안 됨: 충돌로 인해 모든 쓰기가 중단됨",
|
||
batchPartial: "일괄 작업이 부분적으로 완료되었습니다. 실패한 항목을 검토하세요",
|
||
batchCancelled: "취소됨",
|
||
batchCancelledSummary: "동기화 취소됨: {processed}/{total} 처리됨",
|
||
batchFailedSummary: "동기화 부분 완료: {written}개 쓰기, {failed}개 실패",
|
||
batchPartialSummary: "동기화 불완전: {processed}/{total} 처리됨",
|
||
batchFinishedWithSkipped: "동기화 완료: {written}개 쓰기, {skipped}개 건너뜀",
|
||
batchStatusCreate: "생성 예정",
|
||
batchStatusConflict: "충돌",
|
||
batchStatusInvalid: "잘못됨",
|
||
batchStatusCreated: "생성됨",
|
||
batchStatusOverwritten: "덮어쓰기됨",
|
||
batchStatusSkipped: "건너뜀",
|
||
batchStatusFailed: "실패",
|
||
batchStatusAborted: "실행 안 됨",
|
||
batchStatusExported: "내보냄",
|
||
batchStatusUnknown: "{status}",
|
||
reportWritten: "{count}개 쓰기",
|
||
reportCreated: "{count}개 생성",
|
||
reportOverwritten: "{count}개 덮어쓰기",
|
||
reportSkipped: "{count}개 건너뜀",
|
||
reportFailed: "{count}개 실패",
|
||
reportItems: "구성 상세 ({count})",
|
||
history: "기록",
|
||
configHistory: "구성 기록",
|
||
historyUnavailable: "이 연결에서는 구성 기록을 사용할 수 없습니다. r-nacos 콘솔 URL을 구성하고 다시 연결하여 활성화하세요.",
|
||
historyDisabled: "이 연결에서는 구성 기록이 비활성화되었습니다.",
|
||
historyConsoleUrlMissing: "구성 기록에는 r-nacos 콘솔 주소가 필요합니다.",
|
||
historyConsoleCredentialsMissing: "구성 기록에는 r-nacos 콘솔 자격 증명이 필요합니다.",
|
||
rnacosConsoleAuthTitle: "r-nacos 콘솔 인증",
|
||
rnacosConsoleAuthDescription: "구성 타입, 설명, 기록을 읽으려면 r-nacos 콘솔 인증 코드를 입력하세요.",
|
||
rnacosCaptchaLabel: "인증 코드",
|
||
rnacosCaptchaPlaceholder: "위에 표시된 코드 입력",
|
||
rnacosCaptchaRequired: "인증 코드는 필수입니다.",
|
||
rnacosCaptchaUnavailable: "r-nacos가 인증 이미지를 반환하지 않았습니다.",
|
||
rnacosRefreshCaptcha: "코드 새로고침",
|
||
rnacosConsoleAuthSubmit: "인증 후 계속",
|
||
historyDetail: "기록 상세",
|
||
historyCompareTitle: "기록 버전 비교",
|
||
currentPublishedContent: "현재 게시된 내용:",
|
||
historyVersionContent: "기록 버전 내용:",
|
||
updatedAt: "업데이트 시간",
|
||
operationType: "작업",
|
||
operator: "운영자",
|
||
view: "보기",
|
||
compare: "비교",
|
||
rollback: "롤백",
|
||
loadingHistory: "기록을 불러오는 중...",
|
||
noHistory: "기록 버전이 없습니다",
|
||
noHistoryHint: "이 구성을 방금 게시했다면 새로고침하세요. 일부 Nacos 버전은 기록 API를 노출하지 않을 수 있습니다.",
|
||
historyCreate: "생성",
|
||
historyUpdate: "수정",
|
||
historyDelete: "삭제",
|
||
historyRollback: "롤백",
|
||
confirmRollbackTitle: "Nacos 구성 롤백",
|
||
confirmRollbackMessage: "현재 구성을 선택한 기록 버전으로 롤백합니다.",
|
||
rollbackSuccess: "구성을 롤백했습니다",
|
||
publish: "게시",
|
||
validate: "검증",
|
||
validationPassed: "구성 구문이 올바릅니다",
|
||
validationErrorTitle: "구성 구문 오류",
|
||
validationErrorDescription: "게시하기 전에 구문 오류를 수정하세요.",
|
||
validationLine: "줄: {line}",
|
||
validationColumn: "열: {column}",
|
||
validationLocate: "오류 위치",
|
||
dataIdRequired: "데이터 ID는 필수입니다",
|
||
allGroups: "모든 그룹",
|
||
noConfigs: "구성이 없습니다",
|
||
selectConfig: "구성을 선택하거나 만드세요",
|
||
noServices: "서비스가 없습니다",
|
||
selectService: "서비스를 선택하세요",
|
||
service: "서비스",
|
||
instances: "인스턴스",
|
||
instanceCount: "인스턴스 {count}개",
|
||
refresh: "새로고침",
|
||
address: "주소",
|
||
cluster: "클러스터",
|
||
weight: "가중치",
|
||
state: "상태",
|
||
actions: "작업",
|
||
query: "쿼리",
|
||
body: "본문",
|
||
response: "응답",
|
||
template: "템플릿",
|
||
configDiffTitle: "구성 내용 비교",
|
||
inlineCompare: "인라인 비교",
|
||
diffStats: "+{added} / -{removed} / ~{modified}줄",
|
||
previousDifference: "이전 차이",
|
||
nextDifference: "다음 차이",
|
||
currentVersionContent: "현재 공식 버전:",
|
||
publishVersionContent: "이번 릴리스 내용:",
|
||
confirmSaveTitle: "Nacos 구성 변경 검토",
|
||
confirmDeleteTitle: "Nacos 구성 삭제",
|
||
confirmDeleteMessage: "선택한 구성을 Nacos에서 제거합니다.",
|
||
confirmInstanceTitle: "Nacos 인스턴스 업데이트",
|
||
confirmInstanceMessage: "대상 서비스 인스턴스 상태를 확인하세요.",
|
||
confirmRawTitle: "변경 Raw API 요청 보내기",
|
||
confirmRawMessage: "이 Raw API 요청은 Nacos 상태를 수정할 수 있습니다.",
|
||
rawTemplate: {
|
||
serverState: "서버 상태",
|
||
namespaceList: "네임스페이스 목록",
|
||
configDetail: "구성 상세",
|
||
serviceList: "서비스 목록",
|
||
instanceList: "인스턴스 목록",
|
||
},
|
||
healthy: "정상",
|
||
unhealthy: "비정상",
|
||
enabled: "활성화됨",
|
||
offline: "오프라인",
|
||
ephemeral: "임시",
|
||
persistent: "영구",
|
||
enable: "활성화",
|
||
disable: "비활성화",
|
||
markHealthy: "정상",
|
||
markUnhealthy: "비정상",
|
||
send: "보내기",
|
||
total: "전체 {count}",
|
||
prev: "이전",
|
||
next: "다음",
|
||
test: "테스트",
|
||
readOnly: "읽기 전용",
|
||
nacosConnectionPlan: "연결 방식",
|
||
nacosConnectionPlanDescription: "서비스 구현과 API 버전을 선택합니다.",
|
||
nacosApiPlane: "Nacos 3 API 모드",
|
||
nacosApiPlaneAdmin: "Admin API",
|
||
nacosApiPlaneAdminHint: "권장 · 전체 관리 기능",
|
||
nacosApiPlaneConsole: "Console API",
|
||
nacosApiPlaneConsoleHint: "제한됨 · Console 전용 환경용",
|
||
nacosServiceAddress: "서비스 주소",
|
||
nacosServiceAddressHint: "서비스 주소를 입력하세요. 기본 포트는 8848입니다(예: http://host:8848/nacos).",
|
||
nacosConsoleServiceAddressHint: "Console API 주소를 입력하세요. 기본 포트는 8080입니다(예: http://host:8080).",
|
||
nacosManagedNamespaces: "관리할 네임스페이스 ID",
|
||
nacosManagedNamespacesNameOrId: "관리할 네임스페이스 이름 또는 ID",
|
||
nacosManagedNamespacesPlaceholder: "예: public, team-a",
|
||
nacosManagedNamespacesIdPlaceholder: "예: public, f8b8c4e2-8195-4041-adb2-683a8259384b",
|
||
nacosManagedNamespacesHint: "이 일반 사용자가 접근할 수 있는 네임스페이스 ID를 쉼표 또는 줄바꿈으로 입력하세요. 연결 테스트에서 각 ID의 구성 및 서비스 읽기 권한을 확인합니다.",
|
||
nacosOrdinaryAccount: "일반 사용자",
|
||
nacosOrdinaryAccountHint: "위 계정이 일반 사용자인 경우 이 옵션을 켜고 권한이 있는 네임스페이스를 지정하세요. 지정하지 않으면 연결 후 정상적으로 사용할 수 없습니다.",
|
||
nacosManagedNamespacesSeparator: "쉼표 또는 줄바꿈으로 구분",
|
||
nacosOrdinaryNamespacesRequired: "일반 사용자가 관리할 수 있는 네임스페이스 ID를 하나 이상 입력하세요.",
|
||
nacosManagedNamespacesRequired: "이 Nacos 일반 사용자는 네임스페이스 또는 권한 정보를 조회할 수 없습니다. 관리 권한이 있는 네임스페이스 ID를 하나 이상 입력한 후 다시 시도하세요.",
|
||
nacosManagedNamespaceAccessDenied: "다음 네임스페이스가 구성 또는 서비스 읽기 권한 검사에 실패했습니다: {detail}",
|
||
nacosNamespaceAccessScope: "네임스페이스 접근 범위",
|
||
nacosNamespaceAccessScopeHint: "먼저 접근 가능한 네임스페이스를 감지하세요. 나열할 수 없으면 확인된 ID를 직접 입력할 수 있습니다.",
|
||
nacosNamespaceAccessAutomatic: "자동 감지",
|
||
nacosNamespaceAccessManual: "수동 입력",
|
||
nacosDetectAccessibleNamespaces: "접근 가능한 네임스페이스 감지 및 선택",
|
||
nacosDetectAccessibleNamespacesHint: "DBX는 {name}에 대해 네임스페이스를 표시하기 전에 구성 및 서비스 읽기 권한을 확인합니다.",
|
||
nacosV3AdminNamespaceScopeHint: "Nacos 3 Admin API는 일반적으로 관리자 계정이 필요합니다. 제한된 계정은 Console API를 사용하세요.",
|
||
nacosV3AdminManagedNamespacesHint: "이 연결은 Nacos 3 Admin API(일반적으로 포트 8848)를 사용합니다. 일반 사용자는 표시 이름이 아니라 네임스페이스 ID를 입력해야 합니다. Nacos Console의 네임스페이스 상세 정보 또는 역할 권한 리소스에서 ID를 복사하세요.",
|
||
nacosV3ConsoleManagedNamespacesHint: "이 연결은 Nacos 3 Console API(일반적으로 포트 8080)를 사용합니다. 네임스페이스 이름이나 ID를 입력할 수 있으며, 디렉터리를 읽을 수 있으면 DBX가 이름을 실제 ID로 변환합니다.",
|
||
rnacosNamespaceAccessScopeHint: "r-nacos는 콘솔 프로필을 사용할 수 있을 때 현재 사용자의 네임스페이스 권한에서 접근 범위를 가져옵니다.",
|
||
nacosAuth: "인증",
|
||
nacosAuthHint: "이 자격 증명은 연결 테스트와 일상적인 관리에 사용됩니다.",
|
||
nacosUsernamePassword: "사용자 이름 / 비밀번호",
|
||
nacosAdvancedHint: "추가 연결 옵션은 고급 탭에서 설정할 수 있습니다.",
|
||
nacosAdvancedHintDescription: "Prometheus 메트릭, 페이지 크기, TLS 검증 및 r-nacos 확장을 설정합니다.",
|
||
nacosGoAdvanced: "고급으로 이동",
|
||
nacosV3ConsolePortWarning: "8080은 Nacos 3 Web Console의 기본 포트입니다. 서비스 관리는 8848 포트의 Server / Admin API 주소(예: http://127.0.0.1:8848/nacos)를 사용하세요.",
|
||
nacosV3AdminPortWarning: "8848은 일반적으로 Admin API 포트입니다. Console API 모드에서는 보통 http://127.0.0.1:8080인 Console 주소를 사용하세요.",
|
||
nacosAdvancedTitle: "Nacos 고급 연결 옵션",
|
||
nacosAdvancedDescription: "안전한 기본값이 적용되어 있으며, 사용자 지정 배포·메트릭·r-nacos 확장을 사용할 때만 조정하면 됩니다.",
|
||
nacosContextPathHint: "선택한 프로필의 기본값을 사용하려면 비워 두세요. 서버 루트를 명시하려면 /를 입력하고, 리버스 프록시 접두사는 /nacos와 같이 입력하세요.",
|
||
nacosPageSizeHint: "구성 및 서비스 목록에 사용되며 페이지당 1~500개입니다.",
|
||
nacosMetricsHint: "서비스 주소에서 메트릭을 자동으로 조회합니다. 메트릭 엔드포인트가 다르면 사용자 지정 URL을 선택하세요.",
|
||
nacosRnacosExtension: "r-nacos 확장",
|
||
nacosRnacosExtensionHint: "구성 이력·설명 조회와 비활성 인스턴스 관리를 활성화합니다.",
|
||
nacosEnabled: "활성화됨",
|
||
nacosRnacosConsoleUrlHint: "일반적으로 http://host:10848입니다.",
|
||
nacosRnacosDisabledHint: "비활성화하면 서비스 주소만 사용하며, 기본 구성 및 서비스 관리는 계속 사용할 수 있습니다.",
|
||
nacosTlsHint: "신뢰할 수 있는 자체 서명 HTTPS 인증서에만 활성화하세요.",
|
||
nacosVisibleNamespacesTitle: "표시할 네임스페이스 선택",
|
||
nacosVisibleNamespacesDetailLabel: "표시할 네임스페이스",
|
||
nacosVisibleNamespacesDetailActionLabel: '"{connection}"의 표시할 네임스페이스 구성',
|
||
nacosVisibleNamespacesDescription: "{name}의 사이드바에 표시할 네임스페이스를 선택합니다.",
|
||
nacosSearchNamespaces: "네임스페이스 검색...",
|
||
nacosSelectedNamespaces: "{selected}/{total}개 선택됨",
|
||
nacosSelectAll: "모두 선택",
|
||
nacosClearSelection: "지우기",
|
||
nacosShowAll: "모두 표시",
|
||
nacosNamespaceSelectionRequired: "하나 이상 선택하거나 “모두 표시”로 필터를 해제하세요.",
|
||
nacosLoadNamespacesFailed: "네임스페이스를 불러오지 못했습니다: {message}",
|
||
capabilityReadOnly: "이 연결은 읽기 전용입니다.",
|
||
capabilityReadOnlyWrite: "이 구현은 읽기 작업만 제공하며 쓰기 호환성은 확인되지 않았습니다.",
|
||
capabilityVersionUnsupported: "이 Nacos 버전은 해당 작업을 지원하지 않습니다.",
|
||
capabilityEndpointUnavailable: "이 연결에는 관리 엔드포인트가 없습니다.",
|
||
capabilityNotVerified: "현재 구현에서 이 작업이 검증되지 않았습니다.",
|
||
capabilityHeaderReadOnly: "읽기 전용 연결이므로 서비스 및 인스턴스 쓰기가 비활성화되었습니다.",
|
||
protectionTriggeredDescription: "정상 인스턴스 비율이 설정된 보호 임계값보다 낮아 보호 모드가 활성화되었습니다. Nacos는 빈 목록 대신 비정상 인스턴스를 반환할 수 있습니다.",
|
||
instanceEphemeral: "임시 인스턴스",
|
||
instancePersistent: "영구 인스턴스",
|
||
instanceUnknown: "알 수 없는 인스턴스 유형",
|
||
instanceConfirmDetails: "네임스페이스: {namespace}\n서비스: {service}\n주소: {ip}:{port}\n클러스터: {cluster}\n유형: {type}",
|
||
serviceUpdateUnconfirmed: "서비스 업데이트를 제출했지만 Nacos가 대상 상태를 아직 반환하지 않았습니다. 서비스 세부 정보를 새로 고쳐 확인하세요.",
|
||
invalidWeight: "가중치는 0 이상인 유한한 숫자여야 합니다.",
|
||
invalidWeightInput: "0 이상인 유한한 가중치를 입력하세요.",
|
||
metadataLabel: "메타데이터",
|
||
viewMetadataTable: "표로 보기",
|
||
instanceMetadataTitle: "인스턴스 메타데이터",
|
||
metadataKey: "키",
|
||
metadataValue: "값",
|
||
selectorLabel: "셀렉터",
|
||
instanceUpdateUnconfirmed: "인스턴스 업데이트를 제출했지만 Nacos가 새 상태를 아직 반환하지 않았습니다. 새로 고쳐 서버 상태를 확인하세요.",
|
||
instanceRegisterUnconfirmed: "인스턴스 등록을 제출했지만 Nacos가 인스턴스를 아직 반환하지 않았습니다. 새로 고쳐 확인하세요.",
|
||
instanceDeregisterUnconfirmed: "인스턴스 등록 해제를 제출했지만 Nacos가 아직 인스턴스를 반환합니다. 새로 고쳐 확인하세요.",
|
||
serviceValidation: "서비스 이름과 그룹은 필수이며 보호 임계값은 0~1 사이여야 합니다.",
|
||
serviceHasInstances: "서비스에 아직 인스턴스가 있어 삭제할 수 없습니다.",
|
||
serviceDeleteUnconfirmed: "서비스 삭제를 제출했지만 Nacos가 아직 서비스를 반환합니다. 다시 불러와 확인하세요.",
|
||
instanceValidation: "유효한 IP, 포트 및 음수가 아닌 가중치를 입력하세요.",
|
||
protectionTriggered: "보호 모드 활성화",
|
||
loadedInstances: "{count}개 인스턴스 로드됨",
|
||
filterInstanceCluster: "인스턴스 클러스터 필터",
|
||
filter: "필터",
|
||
clear: "지우기",
|
||
serviceSettings: "서비스 설정",
|
||
serviceDetails: "서비스 세부 정보",
|
||
expand: "펼치기",
|
||
instanceStat: "인스턴스",
|
||
healthyInstances: "정상 인스턴스",
|
||
clusterCount: "클러스터",
|
||
protectThreshold: "보호 임계값",
|
||
itemCount: "{count}개 항목",
|
||
temporaryService: "임시 서비스",
|
||
loadingServiceDetail: "서비스 세부 정보 로드 중…",
|
||
refreshDetail: "세부 정보 새로 고침",
|
||
noMetadata: "메타데이터 없음",
|
||
noInstances: "인스턴스 없음",
|
||
createNacosService: "Nacos 서비스 만들기",
|
||
editNacosService: "Nacos 서비스 편집",
|
||
manageServiceMetadata: "서비스 메타데이터와 보호 임계값을 관리합니다.",
|
||
serviceName: "서비스 이름",
|
||
groupName: "그룹",
|
||
thresholdExample: "예: 0.5",
|
||
jsonObject: "JSON 객체",
|
||
optionalJsonObject: "JSON 객체(선택 사항)",
|
||
jsonObjectValidation: " JSON 객체여야 합니다.",
|
||
registerPersistentInstance: "영구 인스턴스 등록",
|
||
persistentInstanceHint: "DBX는 하트비트를 유지할 수 없으므로 임시 인스턴스를 등록하지 않습니다.",
|
||
ipAddress: "IP 주소",
|
||
port: "포트",
|
||
instanceEditorTitle: "인스턴스 편집",
|
||
deleteNacosService: "Nacos 서비스 삭제",
|
||
confirmEmptyServiceDelete: "이 빈 서비스를 삭제하시겠습니까? 이 작업은 취소할 수 없습니다.",
|
||
deregisterNacosInstance: "Nacos 인스턴스 등록 해제",
|
||
confirmInstanceDeregister: "현재 서비스에서 이 인스턴스의 등록을 해제하시겠습니까?",
|
||
edit: "편집",
|
||
restore: "복원",
|
||
registerInstance: "인스턴스 등록",
|
||
deregister: "등록 해제",
|
||
},
|
||
doltVersionControl: {
|
||
title: "Dolt 버전 관리",
|
||
open: "버전 관리",
|
||
branches: "브랜치",
|
||
branchTreeView: "트리 보기",
|
||
branchFlatView: "목록 보기",
|
||
expandBranch: "브랜치 그룹 펼치기",
|
||
collapseBranch: "브랜치 그룹 접기",
|
||
tags: "태그",
|
||
filterRefs: "브랜치 및 태그 필터",
|
||
noBranches: "브랜치 없음",
|
||
noTags: "태그 없음",
|
||
unknownBranch: "알 수 없는 브랜치",
|
||
switchDatabase: "데이터베이스 전환",
|
||
switchBranch: "브랜치 전환",
|
||
workingTree: "작업 트리",
|
||
stagedChanges: "스테이징됨 {count}",
|
||
unstagedChanges: "스테이징 안 됨 {count}",
|
||
uncommitted: "커밋되지 않음",
|
||
stageAllChanges: "모든 변경 사항 스테이징",
|
||
commitWorkingTree: "작업 트리 커밋",
|
||
commitWorkingTreeDescription: "커밋 메시지를 입력하면 작업 트리 변경 사항을 스테이징하고 커밋합니다.",
|
||
commitMessage: "커밋 메시지",
|
||
commitMessagePlaceholder: "예: 주문 상태 수정",
|
||
commitMessageRequired: "커밋 메시지를 입력하세요.",
|
||
changesStaged: "작업 트리 변경 사항을 스테이징했습니다",
|
||
workingTreeCommitted: "작업 트리 변경 사항을 커밋했습니다",
|
||
comparison: "현재 비교",
|
||
swapComparison: "비교 대상 바꾸기",
|
||
noRevision: "리비전 없음",
|
||
compareCurrent: "현재 브랜치와 비교",
|
||
checkoutBranch: "브랜치로 전환",
|
||
branchCheckedOut: "브랜치 {name}(으)로 전환됨",
|
||
graph: "그래프",
|
||
commit: "커밋",
|
||
author: "작성자",
|
||
date: "날짜",
|
||
loadingGraph: "커밋 그래프를 불러오는 중...",
|
||
noCommits: "커밋 없음",
|
||
noMessage: "커밋 메시지 없음",
|
||
changedTables: "변경된 테이블",
|
||
loadingDiff: "리비전 차이를 불러오는 중...",
|
||
noChanges: "두 리비전 사이에 테이블 변경이 없습니다.",
|
||
rowDiff: "행 차이",
|
||
rows: "{count}개 행",
|
||
loadingRows: "행 차이를 불러오는 중...",
|
||
selectTable: "변경된 테이블을 선택하세요",
|
||
noRowChanges: "행 변경이 없습니다. 스키마만 변경되었을 수 있습니다.",
|
||
createBranch: "브랜치 생성",
|
||
createTag: "태그 생성",
|
||
mergeBranch: "브랜치 병합",
|
||
deleteBranch: "브랜치 삭제",
|
||
deleteTag: "태그 삭제",
|
||
createBranchDescription: "선택한 리비전 또는 현재 브랜치에서 새 브랜치를 생성합니다.",
|
||
createTagDescription: "선택한 리비전 또는 현재 브랜치에서 태그를 생성합니다.",
|
||
mergeBranchDescription: "브랜치 {name}을(를) 활성 브랜치에 병합합니다.",
|
||
deleteBranchDescription: "브랜치 {name}을(를) 삭제합니다. 이 작업은 취소할 수 없습니다.",
|
||
deleteTagDescription: "태그 {name}을(를) 삭제합니다. 이 작업은 취소할 수 없습니다.",
|
||
branchName: "브랜치 이름",
|
||
branchNamePlaceholder: "feature/my-branch",
|
||
tagName: "태그 이름",
|
||
tagNamePlaceholder: "v1.0.0",
|
||
branchSource: "소스 리비전: {revision}",
|
||
branchNameRequired: "브랜치 이름을 입력하세요.",
|
||
tagNameRequired: "태그 이름을 입력하세요.",
|
||
branchCreated: "브랜치 {name} 생성됨",
|
||
branchMerged: "브랜치 {name} 병합됨",
|
||
branchDeleted: "브랜치 {name} 삭제됨",
|
||
tagCreated: "태그 {name} 생성됨",
|
||
tagDeleted: "태그 {name} 삭제됨",
|
||
copyHash: "커밋 해시 복사",
|
||
revertCommit: "이 커밋 되돌리기",
|
||
hardResetToCommit: "현재 브랜치를 이 커밋으로 하드 리셋",
|
||
revertCommitTitle: "커밋 되돌리기",
|
||
hardResetTitle: "현재 브랜치 하드 리셋",
|
||
revertCommitDescription: "커밋 {hash}의 변경 사항을 되돌리는 새 커밋을 생성합니다.",
|
||
hardResetDescription: "브랜치 {branch}를 커밋 {hash}로 하드 리셋합니다. 이후 커밋과 스테이징 및 미스테이징 작업 트리 변경 사항이 현재 상태에서 제거됩니다.",
|
||
highRiskConfirmation: "고위험 작업입니다. 계속하기 전에 대상 커밋을 확인하세요.",
|
||
revertCommitComplete: "커밋 {hash}을(를) 되돌렸습니다",
|
||
hardResetComplete: "현재 브랜치를 {hash}(으)로 하드 리셋했습니다",
|
||
discardWorkingTree: "작업 트리 변경 사항 폐기",
|
||
discardWorkingTreeDescription: "스테이징 및 스테이징되지 않은 작업 트리 변경 사항을 모두 폐기합니다. 되돌릴 수 없습니다.",
|
||
discardWorkingTreeComplete: "작업 트리 변경 사항을 폐기했습니다",
|
||
sqlPreview: "SQL 미리보기",
|
||
hashCopied: "커밋 해시가 복사됨",
|
||
copyCurrentValue: "현재 값 복사",
|
||
copyBeforeValue: "변경 전 값 복사",
|
||
copyAfterValue: "변경 후 값 복사",
|
||
cellValueCopied: "셀 값을 복사했습니다",
|
||
viewCellDiff: "차이점 세부 정보 보기",
|
||
cellDiffTitle: "{table}.{column} 차이점",
|
||
cellDiffFormat: "비교 형식",
|
||
cellDiffFormatAuto: "자동",
|
||
cellDiffFormatRaw: "원본",
|
||
cellDiffDetectedFormat: "감지됨: {format}",
|
||
cellDiffFormatFailed: "형식을 지정하지 못해 원본 값을 표시합니다: {message}",
|
||
cellNullValue: "NULL",
|
||
cellRowMissing: "행이 존재하지 않습니다",
|
||
cellColumnMissing: "열이 존재하지 않습니다",
|
||
},
|
||
codeSnapshot: {
|
||
title: "코드 스냅샷",
|
||
close: "닫기",
|
||
copy: "클립보드에 복사",
|
||
save: "PNG 저장",
|
||
copied: "복사됨",
|
||
saved: "저장됨",
|
||
failed: "실패: {message}",
|
||
take: "코드 스냅샷",
|
||
theme: "테마",
|
||
themeLight: "라이트",
|
||
themeDark: "다크",
|
||
windowControls: "창 컨트롤",
|
||
lineNumbers: "줄 번호",
|
||
titleLabel: "제목 (선택)",
|
||
titlePlaceholder: "예: 쿼리 예시",
|
||
},
|
||
gridSnapshot: {
|
||
open: "선택한 셀 스냅샷",
|
||
openRows: "선택한 행 스냅샷",
|
||
openColumns: "선택한 열 스냅샷",
|
||
title: "그리드 스냅샷",
|
||
copied: "복사됨",
|
||
saved: "저장됨",
|
||
failed: "실패: {message}",
|
||
reset: "재설정",
|
||
rows: "{count}개 행",
|
||
columns: "{count}개 열",
|
||
cells: "{count}개 셀",
|
||
appearance: "모양",
|
||
layout: "레이아웃",
|
||
fieldMetadata: "필드 메타데이터",
|
||
theme: "테마",
|
||
windowControls: "창 컨트롤",
|
||
fieldNames: "필드 이름",
|
||
columnTypes: "필드 유형",
|
||
columnDetails: "필드 설명",
|
||
rowNumbers: "행 번호",
|
||
wrapCells: "셀 내용 줄 바꿈",
|
||
transpose: "전치",
|
||
compact: "셀 간격 좁게",
|
||
titleLabel: "제목 (선택)",
|
||
titlePlaceholder: "예: 쿼리 결과",
|
||
},
|
||
});
|