7236 lines
390 KiB
TypeScript
7236 lines
390 KiB
TypeScript
import { withEnglishFallback } from "./fallback";
|
||
import docs from "./docs/ko";
|
||
import { consulUiMessages } from "./consulUi";
|
||
import { sqlServerTraceMessages as sqlServerTrace } from "./sqlServerTraceMessages";
|
||
|
||
const consul = {
|
||
...consulUiMessages,
|
||
prefixPlaceholder: "Key prefix, e.g. app/ or services/",
|
||
newKey: "New Key",
|
||
loadingKeys: "Loading keys...",
|
||
empty: "No keys found",
|
||
loadMore: "Load more",
|
||
selectKey: "Select a key to view its value",
|
||
loadingValue: "Loading value...",
|
||
notFound: "Key not found",
|
||
edit: "Edit",
|
||
editKey: "Edit Key",
|
||
delete: "Delete",
|
||
deleteTitle: "Delete Consul KV key",
|
||
keyLabel: "키(Key)",
|
||
keyPlaceholder: "path/to/key",
|
||
keyRequired: "Key is required",
|
||
rootReadonly: "The root prefix cannot be modified. Enter a key path.",
|
||
saved: "Key saved",
|
||
deleted: "Key deleted",
|
||
base64Readonly: "Edit binary values in Base64 mode.",
|
||
rename: "이름 변경",
|
||
clone: "복제",
|
||
copyKey: "Key 복사",
|
||
export: "내보내기",
|
||
value: "Value",
|
||
valueContent: "값",
|
||
format: "형식",
|
||
metadata: "KV metadata",
|
||
prettyJson: "Pretty",
|
||
invalidJson: "Invalid JSON",
|
||
summarySize: "Size",
|
||
conflict: "This Key changed after it was loaded. Refresh it and try again.",
|
||
keyAlreadyExists: "A Key with this name already exists. Choose another name or edit the existing Key.",
|
||
aclFiltered: "Some Consul KV keys are hidden by ACL policies.",
|
||
locked: "This Key is held by a Consul Session and cannot be edited or deleted.",
|
||
valueTooLarge: "Consul KV values cannot exceed 512 KiB.",
|
||
watchKey: "감시",
|
||
stopWatching: "중지",
|
||
workspace: {
|
||
overview: "개요",
|
||
kv: "KV",
|
||
services: "Services",
|
||
health: "Health",
|
||
sessions: "Sessions",
|
||
scope: "Scope",
|
||
mesh: "Service Mesh",
|
||
tools: "Tools",
|
||
operator: "Operator",
|
||
refresh: "기능 정보 새로 고침",
|
||
loading: "Consul 기능을 불러오는 중...",
|
||
agentIdentity: "Agent 정보",
|
||
capabilities: "기능",
|
||
version: "버전",
|
||
edition: "에디션",
|
||
datacenter: "데이터센터",
|
||
node: "Agent 노드",
|
||
mode: "Agent 모드",
|
||
agent: "Agent API",
|
||
acl: "ACL",
|
||
namespaces: "네임스페이스",
|
||
partitions: "관리 파티션",
|
||
enterprise: "Enterprise",
|
||
community: "Community",
|
||
serverMode: "Server",
|
||
clientMode: "Client",
|
||
capability: {
|
||
supported: "지원",
|
||
unsupported: "지원 안 함",
|
||
forbidden: "권한 없음",
|
||
unknown: "알 수 없음",
|
||
},
|
||
},
|
||
};
|
||
|
||
export default withEnglishFallback({
|
||
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,
|
||
auth: {
|
||
rateLimited: "{seconds}초 후에 다시 시도해 주세요",
|
||
setupTitle: "접속 비밀번호 설정",
|
||
setupDescription: "인스턴스를 보호할 비밀번호를 설정하세요",
|
||
loginDescription: "데이터베이스 관리 도구",
|
||
newPassword: "새 비밀번호 입력",
|
||
confirmPassword: "비밀번호 확인",
|
||
enterPassword: "접속 비밀번호 입력",
|
||
passwordMismatch: "비밀번호가 일치하지 않습니다",
|
||
setPassword: "비밀번호 설정",
|
||
login: "로그인",
|
||
processing: "처리 중...",
|
||
loginFailed: "비밀번호가 올바르지 않습니다",
|
||
connectFailed: "연결에 실패했습니다",
|
||
changePassword: "비밀번호 변경",
|
||
oldPassword: "현재 비밀번호",
|
||
oldPasswordWrong: "현재 비밀번호가 올바르지 않습니다",
|
||
passwordChanged: "비밀번호가 변경되었습니다",
|
||
changePasswordFailed: "비밀번호 변경에 실패했습니다",
|
||
changePasswordDescription: "현재 비밀번호를 입력하고 새 비밀번호를 선택하세요",
|
||
},
|
||
toolbar: {
|
||
newConnection: "새 연결",
|
||
newQuery: "새 쿼리",
|
||
execute: "실행",
|
||
executeShortcut: "선택 영역/쿼리 실행 (Cmd+Enter)",
|
||
stopQuery: "쿼리 중지",
|
||
explainPlan: "실행 계획",
|
||
stopExplain: "실행 계획 중지",
|
||
autotrace: "자동 추적 (쿼리를 실행합니다)",
|
||
explainAnalyze: "EXPLAIN ANALYZE (쿼리를 실행합니다)",
|
||
actualPlan: "실제 실행 계획 (SET STATISTICS XML)",
|
||
formatSql: "SQL 정렬",
|
||
formatSqlFailed: "SQL 정렬에 실패했습니다",
|
||
formatAutoDetectFailed: "선택한 내용을 인식하거나 포맷할 수 없습니다",
|
||
compressSql: "SQL 압축",
|
||
keywordCaseLower: "SQL 키워드 소문자 사용",
|
||
keywordCaseUpper: "SQL 키워드 대문자 사용",
|
||
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: "위험한 명령 차단",
|
||
},
|
||
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: {
|
||
title: "업데이트",
|
||
check: "업데이트 확인",
|
||
availableTitle: "업데이트 가능",
|
||
availableMessage: "DBX {latest}을(를) 사용할 수 있습니다. 현재 {current}을(를) 사용 중입니다.",
|
||
upToDate: "DBX가 최신 버전입니다 ({version}).",
|
||
failed: "업데이트 확인에 실패했습니다: {error}",
|
||
rateLimited: "GitHub 업데이트 확인이 일시적으로 제한되었습니다. 릴리스 페이지를 직접 열어 수동으로 확인할 수 있습니다.",
|
||
openRelease: "릴리스 열기",
|
||
ignoreVersion: "이 버전 무시",
|
||
versionIgnored: "{version} 버전을 무시했습니다. 다음 버전이 출시되면 다시 알려드립니다.",
|
||
ignoreVersionFailed: "무시할 버전을 저장하지 못했습니다: {error}",
|
||
downloadAndInstall: "다운로드 및 설치",
|
||
activeTasksBlockUpdate: "{count}개의 작업이 아직 실행 중입니다. DBX를 업데이트하려면 작업이 완료될 때까지 기다려 주세요.",
|
||
portableAutomaticUpdate: "DBX가 서명된 휴대용 ZIP을 다운로드하여 종료 후 DBX.exe만 교체하고 자동으로 다시 시작합니다. portable.dbx와 데이터는 보존됩니다.",
|
||
windows7ManualUpdate: "Windows 7은 전용 WebView2 109 오프라인 설치 프로그램이 필요합니다. 릴리스 페이지를 열어 Windows 7 패키지를 다운로드하여 업데이트하세요.",
|
||
downloading: "다운로드 중 {progress}%",
|
||
downloadFailed: "업데이트 다운로드에 실패했습니다: {error}",
|
||
downloadCanceled: "업데이트 다운로드가 취소되었습니다.",
|
||
networkOrMirrorFailed: "네트워크 연결 시간이 초과되었거나 다운로드 미러에 연결할 수 없습니다. 네트워크를 확인하거나 '릴리스 열기'를 클릭하여 수동으로 다운로드하세요.",
|
||
installing: "업데이트 설치 중...",
|
||
installFailed: "업데이트 설치에 실패했습니다: {error}",
|
||
restart: "종료 후 다시 시작",
|
||
restartFailed: "앱을 다시 시작하는 데 실패했습니다: {error}",
|
||
exitAndUpdate: "종료 후 업데이트",
|
||
dockerUsersRun: "Docker 사용자는 다음 명령을 실행하세요",
|
||
toUpdate: "업데이트하려면",
|
||
},
|
||
sidebar: {
|
||
connections: "연결",
|
||
noConnections: "아직 연결이 없습니다",
|
||
import: "연결 가져오기",
|
||
importDbx: "DBX 설정 가져오기",
|
||
importNavicat: "Navicat NCX 가져오기",
|
||
importDbeaver: "DBeaver 가져오기",
|
||
importDatagrip: "DataGrip 가져오기",
|
||
export: "연결 내보내기",
|
||
collapseAll: "모두 접기",
|
||
collapse: "사이드바 접기",
|
||
expand: "사이드바 펼치기",
|
||
showMore: "{count}개 더 보기...",
|
||
filterByType: "유형별로 필터",
|
||
showActiveConnectionsOnly: "활성 연결만 표시",
|
||
disconnectAllActiveConnections: "모든 활성 연결 끊기",
|
||
sortConnections: "연결 정렬",
|
||
sortConnectionsManual: "수동 순서",
|
||
sortConnectionsAscending: "이름: 가나다순",
|
||
sortConnectionsDescending: "이름: 다나가순",
|
||
searchScopeConnection: "연결",
|
||
searchScopeDatabase: "데이터베이스",
|
||
searchScopeSchema: "스키마",
|
||
searchScopeTable: "테이블",
|
||
searchScopeView: "뷰",
|
||
searchTablesInCurrentScope: "이 데이터베이스에서 테이블 검색...",
|
||
clearTableSearch: "테이블 검색 지우기",
|
||
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 라이브러리",
|
||
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: "폴더 구조순 정렬",
|
||
},
|
||
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: "SQLCipher 키",
|
||
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: "비밀번호",
|
||
savePassword: "비밀번호 저장",
|
||
savePasswordHint: "체크 해제 시 연결할 때마다 입력해야 합니다",
|
||
promptPasswordTitle: "비밀번호 입력",
|
||
promptPasswordMessage: "연결 “{connection}”의 비밀번호를 입력하세요. 로컬에 저장되지 않습니다.",
|
||
promptPasswordPlaceholder: "비밀번호",
|
||
promptPasswordSubmit: "연결",
|
||
promptPasswordCancel: "취소",
|
||
database: "데이터베이스",
|
||
databasePlaceholder: "선택",
|
||
databasePlaceholderRequired: "필수, 기존 데이터베이스 입력",
|
||
databasePlaceholderWithDefault: "선택, 기본값 {database}",
|
||
kingbaseDatabaseRequired: "Kingbase는 연결이나 데이터베이스 목록을 불러오기 전에 기존 데이터베이스가 필요합니다.",
|
||
defaultDatabase: "기본 DB",
|
||
authDatabase: "인증 DB",
|
||
authDatabasePlaceholder: "선택, 보통 admin",
|
||
authMechanism: "인증 방식",
|
||
authMechanismDefault: "기본",
|
||
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 모드를 사용하세요.",
|
||
elasticsearchDirectMode: "직접",
|
||
elasticsearchKibanaProxyMode: "Kibana 프록시",
|
||
elasticsearchKibanaHost: "Kibana 호스트",
|
||
elasticsearchKibanaBasePath: "기본 경로",
|
||
elasticsearchConnectivityCheckPath: "연결 확인 경로",
|
||
elasticsearchConnectivityCheckPathPlaceholder: "/ 또는 /my-index/_search",
|
||
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 토큰은 필수입니다.",
|
||
hiveAuthMode: "인증",
|
||
hiveAuthNone: "없음",
|
||
hivePrincipal: "프린시펄",
|
||
hiveKerberosPrincipalRequired: "Hive 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: "인증서 찾아보기",
|
||
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 시스템 속성이어야 합니다.",
|
||
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 모드를 비활성화로 설정하고 다시 시도하세요.",
|
||
mysqlClientCertBrowse: "클라이언트 인증서 선택",
|
||
mysqlClientKeyBrowse: "클라이언트 개인 키 선택",
|
||
postgresSslMode: "TLS 모드",
|
||
postgresSslModeDisable: "비활성화",
|
||
postgresSslModePrefer: "선호",
|
||
postgresSslModeRequire: "필수",
|
||
postgresSslModeVerifyCa: "CA 확인",
|
||
postgresSslModeVerifyFull: "전체 확인",
|
||
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: "키 네임스페이스 구분자",
|
||
etcdEndpoints: "엔드포인트",
|
||
etcdEndpointsHint: "한 줄에 하나의 엔드포인트. 비워두면 위의 호스트와 포트를 사용합니다.",
|
||
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를 요구할 때 클라이언트 인증서와 개인 키를 함께 제공해야 합니다.",
|
||
etcdClientCertBrowse: "클라이언트 인증서 선택",
|
||
etcdClientKeyBrowse: "클라이언트 개인 키 선택",
|
||
etcdClientCertPairRequired: "클라이언트 인증서와 개인 키를 함께 제공해야 합니다.",
|
||
consulAddress: "Consul API address",
|
||
consulAddressInvalid: "Enter an absolute HTTP or HTTPS Consul API address without credentials, query parameters, or a fragment.",
|
||
consulToken: "ACL Token",
|
||
consulTokenPlaceholder: "Optional Consul ACL Token",
|
||
consulDatacenter: "Datacenter",
|
||
consulNamespace: "Namespace",
|
||
consulPartition: "Admin Partition",
|
||
consulAgentTargetNode: "Agent target node",
|
||
consulAgentTargetAddress: "Agent direct address",
|
||
consulAgentTargetHint: "Required for Agent writes. DNS/load-balanced and Transport Layer endpoints stay read-only.",
|
||
consulMeshFeatures: "Service mesh",
|
||
consulMeshVisible: "Show advanced service mesh workspace",
|
||
consulMeshVisibleHint: "Enable only to manage Connect, intentions, or peering. When disabled, the workspace stays hidden.",
|
||
consulOperatorWrites: "Operator writes",
|
||
consulOperatorVisible: "Show experimental Operator workspace",
|
||
consulOperatorSnapshotRestore: "Enable snapshot restore",
|
||
consulOperatorAutopilot: "Enable Autopilot updates",
|
||
consulOperatorRaft: "Enable Raft changes",
|
||
consulOperatorKeyring: "Enable Keyring changes",
|
||
consulOperatorLicense: "Enable License updates",
|
||
consulAgentTargetIncomplete: "Agent target node and direct address must be configured together.",
|
||
consulAgentTargetAddressMismatch: "Agent direct address must match the Consul endpoint host.",
|
||
consulConsistency: "Read consistency",
|
||
consulConsistencyDefault: "Default",
|
||
consulConsistencyStale: "Stale",
|
||
consulConsistencyConsistent: "Consistent",
|
||
consulTlsSkipVerify: "Skip certificate verification",
|
||
consulTlsSkipVerifyHint: "Use only for trusted self-signed Consul endpoints.",
|
||
zookeeperConnectString: "연결 문자열",
|
||
zookeeperConnectStringHint: "쉼표 또는 줄바꿈으로 구분된 host:port 항목. 비워두면 위의 호스트와 포트를 사용합니다.",
|
||
zookeeperCreateModePersistent: "영구",
|
||
zookeeperCreateModeEphemeral: "임시",
|
||
zookeeperCreateModePersistentSequential: "영구 순차",
|
||
zookeeperCreateModeEphemeralSequential: "임시 순차",
|
||
nacosConsoleUrl: "Nacos 관리 주소",
|
||
nacosConsoleUrlHint: "선택한 Nacos 프로필과 일치하는 주소를 사용하세요. 전체 브라우저와 API URL이 모두 허용됩니다.",
|
||
nacosConsoleUrlRequired: "Nacos 관리 주소는 필수입니다",
|
||
nacosConsoleUrlAutoAdjusted: "Nacos 콘솔 URL을 {from}에서 {to}(으)로 조정했습니다.",
|
||
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 주소가 잘못되었습니다",
|
||
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 런타임 설치 중...",
|
||
saveAndConnect: "저장 후 연결",
|
||
save: "저장",
|
||
editTitle: "연결 편집",
|
||
testSuccess: "연결 성공",
|
||
databaseInfo: {
|
||
title: "데이터베이스 정보",
|
||
open: "{database}의 데이터베이스 정보 열기",
|
||
copy: "데이터베이스 정보 복사",
|
||
sourceConfigured: "현재 구성",
|
||
sourceTested: "테스트됨",
|
||
configuredDescription: "먼저 양식에서 알려진 정보를 표시합니다. 성공적인 테스트는 서버 버전과 드라이버 메타데이터를 추가합니다.",
|
||
testedDescription: "이 정보는 가장 최근 성공한 테스트에 사용된 연결에서 가져왔습니다.",
|
||
productName: "DBMS",
|
||
productVersion: "DBMS 버전",
|
||
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: "그룹을 삭제했습니다",
|
||
loadFailed: "저장된 연결을 불러오는 데 실패했습니다: {message}",
|
||
sshTunnel: "터널 / 프록시",
|
||
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: "취소",
|
||
sshInteractiveTitle: "SSH 인증 필요",
|
||
sshInteractiveMessage: "SSH 서버 {host}:{port}에서 추가 인증을 요구합니다.",
|
||
sshInteractiveDefaultPrompt: "서버에서 요청한 인증 정보를 입력하세요.",
|
||
sshInteractivePlaceholder: "인증 코드 입력",
|
||
sshInteractiveSubmit: "인증",
|
||
sshInteractiveCancel: "취소",
|
||
sshHostKeyNoticeChanged: "{host}:{port}의 호스트 키가 변경되었습니다 — 이는 중간자 공격을 나타낼 수 있습니다. 이 변경을 예상한 경우에만 이전 항목을 제거하고 다시 연결하세요.",
|
||
sshHostKeyNoticeRejected: "{host}:{port}의 호스트 키를 거부했습니다. 연결이 중단되고 자격 증명이 전송되지 않았습니다.",
|
||
sshHostKeyNoticeLearnFailed: "{host}:{port}의 호스트 키를 저장할 수 없습니다 — 이 호스트는 이 세션에만 신뢰되며 다음에 다시 확인을 요청받습니다.",
|
||
sshHostKeyNoticeGeneric: "{host}:{port}의 SSH 호스트 키 검증에 실패했습니다.",
|
||
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: "일회용 코드 입력이 취소되었습니다",
|
||
},
|
||
editor: {
|
||
duckdbDraining: "이전 DuckDB 쿼리가 아직 중지 중입니다. 잠시 후 다시 시도해 주세요.",
|
||
statementExecutionRunning: "{count}개 구문 실행 중",
|
||
statementExecutionSucceeded: "{count}개 구문 성공",
|
||
statementExecutionFailed: "{count}개 구문 실패",
|
||
pressToExecute: "{mod}+Enter를 눌러 실행",
|
||
pressToSaveSql: "{mod}+S를 눌러 SQL 저장",
|
||
queryTimeoutError: "쿼리 시간 초과 ({seconds}초). 데이터베이스 연결이 정상인지 확인하세요.",
|
||
changeQueryTimeout: "쿼리 제한 시간 변경",
|
||
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}개 컬럼",
|
||
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: "선택 영역 복사",
|
||
cutSelection: "선택 영역 잘라내기",
|
||
pasteFromClipboard: "붙여넣기",
|
||
pasteClipboardReadFailed: "클립보드 읽기 실패: {message}",
|
||
sendToAi: "AI로 보내기",
|
||
uppercaseSelection: "대문자로 변환",
|
||
lowercaseSelection: "소문자로 변환",
|
||
delimitedList: "구분자 목록으로 변환",
|
||
expandSelectStar: "*을(를) 열로 확장",
|
||
expandSelectStarUnavailable: "이 테이블의 열을 불러올 수 없습니다",
|
||
findReplace: "찾기/바꾸기",
|
||
deleteEmptyLines: "빈 줄 삭제",
|
||
selectAll: "모두 선택",
|
||
},
|
||
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: "전체 명령",
|
||
},
|
||
},
|
||
tabs: {
|
||
sql: "SQL",
|
||
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: "테이블:",
|
||
tooltipCollection: "컬렉션:",
|
||
tooltipSchema: "스키마:",
|
||
resultN: "결과 {n}",
|
||
runN: "실행 {n}",
|
||
resultRuns: "결과 실행",
|
||
resultSets: "결과 집합",
|
||
removeRun: "실행 {n} 제거",
|
||
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: "열린 탭",
|
||
fixedTabs: "고정 탭",
|
||
openDataTabs: "열린 테이블",
|
||
},
|
||
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을 가져올 수 없습니다",
|
||
navigationHint: "행을 클릭하여 SQL을 미리 보고 두 번 클릭하여 편집기에서 선택하세요.",
|
||
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})",
|
||
totalRowCountAtLeast: "(최소 {count})",
|
||
totalRowCountEstimated: "(약 {count})",
|
||
totalRowCountLoading: "(집계 중...)",
|
||
loadingMore: "데이터를 더 불러오는 중...",
|
||
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",
|
||
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 보기 좋게",
|
||
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 복사",
|
||
copyCell: "셀 복사",
|
||
copyRow: "전체 행 복사(JSON 객체)",
|
||
copyColumnJson: "컬럼 복사 (JSON)",
|
||
copyColumnNames: "컬럼 이름 복사",
|
||
copyColumnNamesSelected: "선택한 컬럼 이름 복사 ({count})",
|
||
copyColumnNamesTitle: "컬럼 이름 복사 ({count})",
|
||
copyColumnNamesSeparator: "컬럼 구분자",
|
||
copyColumnNamesQuote: "컬럼 이름 인용",
|
||
copyColumnNamesPreview: "미리보기",
|
||
copyAll: "모두 복사 (TSV)",
|
||
selectionSum: "합계: {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 내보내기",
|
||
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 입력과 결합하세요.",
|
||
filterBuilderSummary: "{count}개 규칙",
|
||
filterBuilderAddRule: "규칙 추가",
|
||
filterBuilderColumn: "컬럼",
|
||
filterBuilderSearchColumns: "컬럼 검색...",
|
||
filterBuilderNoMatchingColumns: "일치하는 컬럼이 없습니다",
|
||
filterBuilderValue: "값",
|
||
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: "포함하지 않음",
|
||
filterBuilderGreaterThan: "보다 큼",
|
||
filterBuilderGreaterThanOrEqual: "크거나 같음",
|
||
filterBuilderLessThan: "보다 작음",
|
||
filterBuilderLessThanOrEqual: "작거나 같음",
|
||
filterBuilderIn: "목록 내",
|
||
filterBuilderNotIn: "목록 외",
|
||
filterBuilderBetween: "범위 내",
|
||
filterBuilderNotBetween: "범위 외",
|
||
filterBuilderIsNull: "NULL임",
|
||
filterBuilderIsNotNull: "NULL이 아님",
|
||
columnActions: "컬럼 작업",
|
||
localFilter: "로컬 값 필터",
|
||
localFilterFor: "'{column}' 로컬 값",
|
||
databaseValueFilter: "데이터베이스 값 필터",
|
||
databaseValueFilterFor: "'{column}' 데이터베이스 값",
|
||
columnFormatter: "컬럼 포매터",
|
||
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: "컬럼 고정 해제",
|
||
pasted: "붙여넣었습니다!",
|
||
search: "검색...",
|
||
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: "적용",
|
||
generateValue: "값 생성",
|
||
generateEmptyString: "빈 문자열",
|
||
generateNull: "NULL",
|
||
generateCurrentDatetime: "현재 날짜/시간",
|
||
generateCurrentDate: "현재 날짜",
|
||
generateUuid: "UUID",
|
||
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: "복원",
|
||
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 압축",
|
||
formattedJsonEditWarning: "서식된 JSON을 편집하고 있습니다. 저장하면 JSON으로 기록되어 원래 서식이 변경될 수 있습니다.",
|
||
setNull: "NULL 설정",
|
||
restoreOriginalValue: "원래대로 복원",
|
||
copyColumnName: "컬럼 이름 복사",
|
||
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: "테이블 정보",
|
||
tableInfoColumns: "컬럼",
|
||
tableInfoIndexes: "인덱스",
|
||
columnPrimaryIndex: "기본 키 인덱스",
|
||
columnUniqueIndex: "고유 인덱스",
|
||
columnRegularIndex: "일반 인덱스",
|
||
tableInfoForeignKeys: "외래 키",
|
||
foreignKeyNavigate: "{table}(으)로 이동",
|
||
tableInfoTriggers: "트리거",
|
||
tableInfoNullable: "NULL 허용",
|
||
tableInfoEmpty: "메타데이터 없음",
|
||
tableInfoSearch: "검색...",
|
||
tableInfoNoResults: "결과 없음",
|
||
goToColumn: "컬럼으로 이동",
|
||
columnWidth: "컬럼 너비",
|
||
columnWidthCompact: "좁게",
|
||
columnWidthStandard: "표준",
|
||
columnWidthComfortable: "넓게",
|
||
searchColumn: "컬럼/주석 검색...",
|
||
noColumnsFound: "컬럼이 없습니다",
|
||
queryError: "쿼리 오류",
|
||
saveErrorTitle: "변경사항 저장 실패",
|
||
dataUnavailable: "테이블 데이터를 다시 불러와야 합니다.",
|
||
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}행만 로드했습니다. 페이지당 행 수는 로드된 데이터만 나눠 표시합니다. 전체 결과를 가져오려면 시간 범위를 줄이거나 필터를 추가하세요.",
|
||
},
|
||
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}개가 표시되지 않았습니다",
|
||
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}을(를) 열었습니다",
|
||
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가 분류되지 않은 오류를 반환했습니다.",
|
||
},
|
||
legacy: "백엔드에서 오류를 반환했습니다.",
|
||
unknown: "예상하지 못한 백엔드 오류가 발생했습니다.",
|
||
},
|
||
common: {
|
||
fileNotFound: "파일이 존재하지 않습니다: {path}",
|
||
language: "언어",
|
||
loading: "불러오는 중...",
|
||
stopping: "중지하는 중...",
|
||
close: "닫기",
|
||
cancel: "취소",
|
||
confirm: "확인",
|
||
save: "저장",
|
||
clear: "지우기",
|
||
copy: "복사",
|
||
import: "가져오기",
|
||
remove: "제거",
|
||
retry: "다시 시도",
|
||
more: "더보기",
|
||
decrease: "감소",
|
||
increase: "증가",
|
||
showPassword: "비밀번호 표시",
|
||
hidePassword: "비밀번호 숨기기",
|
||
done: "완료",
|
||
connection: "연결",
|
||
database: "데이터베이스",
|
||
table: "테이블",
|
||
view: "뷰",
|
||
materializedView: "구체화된 뷰",
|
||
procedure: "프로시저",
|
||
function: "함수",
|
||
sequence: "시퀀스",
|
||
package: "패키지",
|
||
packageBody: "패키지 본문",
|
||
noResults: "결과 없음",
|
||
edit: "편집",
|
||
delete: "삭제",
|
||
back: "뒤로",
|
||
},
|
||
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 구문만 지원합니다",
|
||
},
|
||
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: "새 그룹",
|
||
groupNamePlaceholder: "그룹 이름",
|
||
selectConnection: "연결 선택",
|
||
deselectConnection: "연결 선택 해제",
|
||
selectAllConnections: "모든 연결 선택",
|
||
deselectAllConnections: "모든 연결 선택 해제",
|
||
selectedConnections: "{count}개 선택",
|
||
exitMultiSelect: "선택 종료",
|
||
renameGroup: "그룹 이름 변경",
|
||
deleteGroup: "그룹 삭제",
|
||
moveToGroup: "그룹으로 이동",
|
||
moveToNewGroup: "새 그룹으로 이동",
|
||
ungrouped: "그룹 없음",
|
||
ungroupedLabel: "그룹 없음",
|
||
newGroup: "새 그룹...",
|
||
newGroupDefault: "새 그룹",
|
||
deleteGroupConfirmTitle: "그룹 삭제",
|
||
deleteGroupConfirmMessage: '그룹 "{name}"을(를) 삭제하시겠습니까? 안의 연결은 최상위로 이동합니다.',
|
||
},
|
||
databaseSearch: {
|
||
title: "데이터베이스 검색",
|
||
open: "데이터베이스 검색",
|
||
keyword: "키워드",
|
||
keywordPlaceholder: "사용자 ID, 이메일, 주문 번호 입력...",
|
||
limitPerTable: "테이블당",
|
||
search: "검색",
|
||
searching: "검색 중",
|
||
stop: "중지",
|
||
hint: "현재 데이터베이스 또는 스키마의 일반 테이블을 스캔합니다. 바이너리 컬럼은 건너뛰고, 각 테이블은 한 번에 너무 많은 데이터를 불러오지 않도록 제한합니다.",
|
||
loadingTables: "테이블 목록을 읽는 중...",
|
||
progress: "테이블 {done}/{total}개 스캔",
|
||
resultCount: "{count}개 일치",
|
||
limitedTables: "대규모 스키마가 감지되어 처음 {count}개 테이블만 스캔합니다",
|
||
results: "결과",
|
||
openResult: "열기",
|
||
waiting: "일치 항목을 기다리는 중...",
|
||
noResults: "아직 일치 항목이 없습니다",
|
||
errors: "일부 테이블이 실패했습니다",
|
||
},
|
||
configExport: {
|
||
passphraseTitle: "암호화 및 내보내기",
|
||
passphraseImportTitle: "복호화 및 가져오기",
|
||
passphraseExportHint: "내보내기에 연결 비밀번호를 포함하려면 암호화용 암호구를 설정하세요. 가져오려면 동일한 암호구가 필요합니다.",
|
||
passphraseImportHint: "이 파일은 암호화되어 있습니다. 복호화하여 가져오려면 암호구를 입력하세요.",
|
||
passphrase: "암호구",
|
||
passphraseConfirm: "암호구 확인",
|
||
passphrasePlaceholder: "암호구 입력",
|
||
passphraseConfirmPlaceholder: "암호구 다시 입력",
|
||
passphraseRequired: "암호구는 필수입니다",
|
||
passphraseMismatch: "암호구가 일치하지 않습니다",
|
||
passphraseTooShort: "암호구는 최소 4자 이상이어야 합니다",
|
||
exportEncrypted: "내보내기",
|
||
decryptImport: "복호화 및 가져오기",
|
||
wrongPassphrase: "암호구가 잘못되었거나 파일이 손상되었습니다",
|
||
cryptoUnavailable: "이 브라우저 환경에서는 암호화된 설정 가져오기를 사용할 수 없습니다. HTTPS, localhost 또는 DBX 데스크톱을 사용하세요.",
|
||
exportSuccess: "연결을 성공적으로 내보냈습니다",
|
||
importSuccess: "연결 {count}개를 가져왔습니다",
|
||
importNavicatSuccess: "Navicat 연결 {count}개를 가져왔습니다. 테스트하기 전에 비밀번호가 비어 있는 연결의 비밀번호를 입력하세요.",
|
||
importDatagripSuccess: "DataGrip 연결 {count}개를 가져왔으며, macOS 키체인에서 비밀번호 {filled}개를 채웠습니다.",
|
||
importDbeaverSuccess: "DBeaver 연결 {count}개를 가져왔습니다. 테스트하기 전에 비밀번호가 비어 있는 연결의 비밀번호를 입력하세요.",
|
||
importNone: "가져올 새 연결이 없습니다",
|
||
importLayoutConfirm: "가져온 파일에 연결 그룹이 포함되어 있습니다. 적용하시겠습니까?",
|
||
importLayoutTitle: "그룹 가져오기",
|
||
importLayoutApply: "적용",
|
||
},
|
||
ai: {
|
||
placeholder: "자연어로 쿼리를 설명하세요...",
|
||
settings: "AI 설정",
|
||
noConfig: "AI가 구성되지 않았습니다. 설정 > AI에서 AI 공급자를 설정하세요.",
|
||
provider: "공급자",
|
||
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: "모두 복사",
|
||
copied: "복사했습니다",
|
||
copyTestResult: "테스트 결과 복사",
|
||
testErrorAuth: "인증 또는 접근에 실패했습니다. API 키, 프로젝트 권한 및 API 가용성을 확인하세요.",
|
||
testErrorModelNotFound: "모델을 사용할 수 없습니다. 모델 ID와 계정 접근 권한을 확인하세요.",
|
||
testErrorRateLimit: "요청 속도 제한이나 할당량을 초과했습니다. 나중에 다시 시도하거나 계정 할당량을 확인하세요.",
|
||
testErrorTimeout: "요청 시간이 초과되었습니다. 네트워크, 프록시 및 엔드포인트를 확인하세요.",
|
||
testErrorTokenLimit: "출력 토큰 한도가 소진되어 표시되는 텍스트가 생성되지 않았습니다.",
|
||
testErrorSafety: "Gemini가 안전 정책에 따라 프롬프트나 응답을 차단했습니다.",
|
||
testErrorEmptyResponse: "서비스나 프록시가 표시되는 텍스트를 반환하지 않고 스트림을 닫았습니다.",
|
||
testErrorNetwork: "네트워크 연결에 실패했습니다. 엔드포인트와 프록시를 확인하세요.",
|
||
testErrorUnknown: "분류되지 않은 이유로 테스트가 실패했습니다.",
|
||
replace: "편집기 교체",
|
||
append: "편집기에 추가",
|
||
apply: "편집기에 적용",
|
||
clear: "채팅 지우기",
|
||
welcome: "쿼리할 내용을 말씀해 주세요. SQL을 작성해 드릴게요",
|
||
requestFailed: "AI 요청 실패",
|
||
newChat: "새 채팅",
|
||
thinking: "생각하는 중...",
|
||
reasoningProcess: "사고 과정",
|
||
chars: "자",
|
||
stopGenerating: "생성 중지",
|
||
scrollToBottom: "맨 아래로",
|
||
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이 자동 실행하기에는 너무 위험해 보입니다. 실행 전에 수동으로 검토하세요.",
|
||
proposalConfirmYes: "예, 진행",
|
||
proposalConfirmNo: "아니오",
|
||
proposalConfirmTitle: "작업 확인이 필요합니다",
|
||
agentSteps: {
|
||
generated: "SQL 생성됨",
|
||
noSql: "SQL을 찾을 수 없음",
|
||
safe: "안전성 통과",
|
||
needsConfirm: "확인 필요",
|
||
blocked: "차단됨",
|
||
autoExecute: "실행 준비됨",
|
||
notRequested: "실행 요청되지 않음",
|
||
skipped: "실행되지 않음",
|
||
callingTool: "도구 호출 중...",
|
||
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: "이 단계는 실행되지 않았습니다.",
|
||
},
|
||
proxy: "프록시",
|
||
proxyEnable: "프록시를 통해 AI 요청 전송",
|
||
proxyUrl: "프록시 URL",
|
||
enableThinking: "사고",
|
||
enableThinkingOn: "활성화됨",
|
||
enableThinkingOff: "비활성화됨",
|
||
enableThinkingHint: "이 옵션은 /chat/completions API와 지원되는 모델에만 적용됩니다. 비활성화하면 토큰 사용량을 크게 줄일 수 있지만, 생성 결과의 품질이 약간 떨어질 수 있습니다.",
|
||
anthropicMessagesHint: "Anthropic Messages 호환 API는 일반적으로 /v1/messages를 사용합니다.",
|
||
openAiCompatibleEndpointHint: "대부분의 OpenAI 호환 API는 /v1 경로 접두사가 필요합니다.",
|
||
contextWindow: "컨텍스트 창",
|
||
contextWindowAuto: "자동 (모델 이름에서 감지)",
|
||
contextWindowHint: "토큰. 자동 감지하려면 비워 두세요. 로컬/사용자 지정 모델은 수동으로 설정하세요.",
|
||
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 대화를 시작할 때 사용되는 모드입니다. 현재 대화에서 모드를 전환해도 이 설정은 변경되지 않습니다.",
|
||
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}자). 계속하려면 일부를 선택 해제하세요.",
|
||
exportMarkdown: "Markdown으로 내보내기",
|
||
analysis: "AI 분석",
|
||
},
|
||
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: "새 쿼리",
|
||
instanceInfo: "인스턴스 정보",
|
||
newSql: "새 SQL",
|
||
generateSql: "SQL 생성",
|
||
newInsert: "새 INSERT",
|
||
newUpdate: "새 UPDATE",
|
||
sqlHistory: "쿼리 기록",
|
||
noSqlHistory: "관련 SQL이 없습니다",
|
||
openObjectBrowser: "객체 탐색",
|
||
openDatabaseBrowser: "데이터베이스 탐색",
|
||
viewData: "데이터 보기",
|
||
openInNewDataTab: "새 탭에서 보기",
|
||
editStructure: "구조 편집",
|
||
editColumn: "컬럼 편집",
|
||
editIndex: "인덱스 편집",
|
||
refreshChildren: "새로고침",
|
||
expandAll: "모두 펼치기",
|
||
tableNameFilters: "필터...",
|
||
tableNameFiltersDescription: "포함 목록과 일치하는 테이블 이름만 표시한 다음 제외 목록과 일치하는 이름을 숨깁니다. 한 줄에 하나의 SQL LIKE 패턴.",
|
||
tableNameFilterInclude: "포함 테이블 패턴",
|
||
tableNameFilterExclude: "제외 테이블 패턴",
|
||
tableNameFilterIncludePlaceholder: "예:\nads_%\nuser_%",
|
||
tableNameFilterExcludePlaceholder: "예:\n%_bak\ntmp_%",
|
||
tableNameFilterLikeHint: "SQL LIKE 문법을 사용하세요: %는 임의의 문자, _는 한 문자와 일치합니다. 대소문자를 구분하지 않습니다.",
|
||
pin: "고정",
|
||
reorderPinned: "고정 항목 재정렬",
|
||
unpin: "고정 해제",
|
||
fixTab: "탭 고정",
|
||
unfixTab: "탭 고정 해제",
|
||
refreshTab: "데이터 새로고침",
|
||
renameTab: "탭 이름 변경",
|
||
duplicateTab: "탭 복제",
|
||
compactTabTitle: "탭 제목 줄이기",
|
||
fullTabTitle: "전체 탭 제목 표시",
|
||
closeTab: "탭 닫기",
|
||
closeFixedTab: "고정 탭 닫기",
|
||
closeOtherTabs: "다른 탭 닫기",
|
||
closeOtherRegularTabs: "다른 일반 탭 닫기",
|
||
closeOtherFixedTabs: "다른 고정 탭 닫기",
|
||
closeAllTabs: "모든 탭 닫기",
|
||
closeAllRegularTabs: "모든 일반 탭 닫기",
|
||
closeAllFixedTabs: "모든 고정 탭 닫기",
|
||
copyName: "이름 복사",
|
||
copyFinalProxyPort: "최종 프록시 포트 복사",
|
||
finalProxyPortCopied: "최종 프록시 포트 {port} 복사됨",
|
||
setDefaultDatabase: "기본 데이터베이스로 설정",
|
||
clearDefaultDatabase: "기본 데이터베이스 지우기",
|
||
setDefaultSchema: "기본 스키마로 설정",
|
||
clearDefaultSchema: "기본 스키마 지우기",
|
||
exportDatabase: "데이터베이스 내보내기",
|
||
exportAllDatabases: "모든 데이터베이스 내보내기",
|
||
exportDatabaseSuccess: "테이블 {count}개 내보냄, 각각 최대 {limit}행",
|
||
exportDatabaseFailed: "데이터베이스 내보내기에 실패했습니다: {message}",
|
||
backupSqliteDatabase: "SQLite 데이터베이스 백업",
|
||
backupSqliteDatabaseInProgress: "SQLite 데이터베이스 백업 중...",
|
||
backupSqliteDatabaseSuccess: "SQLite 데이터베이스를 백업했습니다",
|
||
backupSqliteDatabaseFailed: "SQLite 데이터베이스 백업에 실패했습니다: {message}",
|
||
importData: "데이터 가져오기",
|
||
exportData: "데이터 내보내기",
|
||
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: "희소",
|
||
dropForeignKey: "외래 키 삭제",
|
||
dropTrigger: "트리거 삭제",
|
||
batchDrop: "선택 항목 삭제 ({count})",
|
||
batchEmpty: "선택 항목 비우기 ({count})",
|
||
batchTruncate: "선택 항목 TRUNCATE ({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하시겠습니까? 모든 행이 제거됩니다.",
|
||
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}",
|
||
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: "컬렉션 삭제",
|
||
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}" 주석이 업데이트되었습니다',
|
||
},
|
||
visibleDatabases: {
|
||
title: "표시할 데이터베이스",
|
||
detailLabel: "표시할 데이터베이스",
|
||
detailActionLabel: '"{connection}"의 표시할 데이터베이스 구성',
|
||
description: '"{connection}" 아래에 표시할 데이터베이스를 선택하세요.',
|
||
searchPlaceholder: "데이터베이스 검색...",
|
||
selectedCount: "{selected}/{total} 선택됨",
|
||
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}",
|
||
},
|
||
tree: {
|
||
savedSql: "SQL 라이브러리",
|
||
queries: "쿼리",
|
||
userAdmin: "사용자 및 권한",
|
||
damengUsers: "사용자",
|
||
damengRoles: "역할",
|
||
damengJobAdmin: "에이전트 작업",
|
||
linkedServers: "연결된 서버",
|
||
defaultDatabase: "기본 DB",
|
||
columns: "컬럼",
|
||
attributes: "속성",
|
||
methods: "메서드",
|
||
indexes: "인덱스",
|
||
foreignKeys: "외래 키",
|
||
triggers: "트리거",
|
||
constraints: "제약 조건",
|
||
tables: "테이블",
|
||
tableNameFilterActive: "필터됨",
|
||
views: "뷰",
|
||
materializedViews: "구체화된 뷰",
|
||
procedures: "프로시저",
|
||
functions: "함수",
|
||
sequences: "시퀀스",
|
||
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: "설치된 확장이 없습니다.",
|
||
},
|
||
processList: {
|
||
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: "호스트",
|
||
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: "데이터베이스를 선택하고 각각에 대해 별도의 권한 수준을 구성하세요.",
|
||
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}" 접근 권한 부여',
|
||
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: "테이블",
|
||
views: "뷰",
|
||
procedures: "프로시저",
|
||
functions: "함수",
|
||
sequences: "시퀀스",
|
||
packages: "패키지",
|
||
table: "테이블",
|
||
partitions: "파티션 {count}개",
|
||
view: "뷰",
|
||
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: "테이블, 뷰, 함수, 시퀀스 또는 프로시저 검색...",
|
||
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: "외래 키",
|
||
triggers: "트리거",
|
||
ddl: "DDL",
|
||
addColumn: "컬럼 추가",
|
||
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: "단위",
|
||
enumValues: "Enum 값",
|
||
enumValueCount: "{count}개 값",
|
||
addEnumValue: "값 추가",
|
||
removeEnumValue: "Enum 값 제거",
|
||
enumValuePlaceholder: "값 (비워도 됨)",
|
||
nullable: "NULL 허용",
|
||
primaryKey: "기본 키",
|
||
defaultValue: "기본값",
|
||
defaultValuePresets: "기본값 프리셋",
|
||
comment: "주석",
|
||
characterSet: "문자셋",
|
||
charsetPlaceholder: "문자셋",
|
||
collation: "정렬",
|
||
collationPlaceholder: "정렬",
|
||
editComment: "주석 편집",
|
||
commentPlaceholder: "컬럼 주석 입력...",
|
||
tableCommentPlaceholder: "테이블 주석 입력...",
|
||
tableCommentUnsupported: "이 데이터베이스는 테이블 주석을 지원하지 않습니다",
|
||
actions: "작업",
|
||
indexName: "인덱스",
|
||
indexColumns: "컬럼",
|
||
indexColumnsPlaceholder: "컬럼 선택...",
|
||
unique: "고유",
|
||
indexType: "타입",
|
||
includedColumns: "포함",
|
||
includedColumnsPlaceholder: "컬럼 선택...",
|
||
filter: "필터",
|
||
foreignKeyName: "외래 키",
|
||
referencedSchema: "참조 스키마",
|
||
referencedTable: "참조 테이블",
|
||
referencedColumn: "참조 컬럼",
|
||
onDelete: "삭제 시",
|
||
onUpdate: "수정 시",
|
||
defaultAction: "기본",
|
||
triggerName: "트리거",
|
||
triggerStatement: "트리거 구문",
|
||
primary: "기본",
|
||
drop: "삭제",
|
||
restore: "복원",
|
||
remove: "제거",
|
||
moveColumnUp: "컬럼을 위로 이동",
|
||
moveColumnDown: "컬럼을 아래로 이동",
|
||
dragColumn: "드래그하여 컬럼 순서 변경",
|
||
localColumnOrderNotice: "컬럼 순서는 로컬에만 저장되며 데이터베이스 테이블 구조를 변경하지 않습니다.",
|
||
yes: "예",
|
||
no: "아니오",
|
||
emptyReadonly: "레코드가 없습니다",
|
||
sqlPreview: "SQL 미리보기",
|
||
collapseSqlPreview: "SQL 미리보기 접기",
|
||
expandSqlPreview: "SQL 미리보기 펼치기",
|
||
noChanges: "변경 사항 없음",
|
||
apply: "변경 사항 적용",
|
||
ready: "준비됨",
|
||
saved: "테이블 구조가 업데이트되었습니다",
|
||
copySql: "SQL 복사",
|
||
sqliteRebuildNotice: "SQLite는 백업으로 비활성 데이터 스냅샷을 유지한 다음 하나의 트랜잭션에서 테이블을 재구성하고 변경된 컬럼을 강제로 CAST합니다. 표현할 수 없는 값은 0/0.0이 될 수 있으며, 실패 시 롤백됩니다.",
|
||
extendedProperties: "확장",
|
||
autoIncrement: "자동 증가",
|
||
onUpdateCurrentTimestamp: "수정 시간 자동 갱신",
|
||
identity: "ID",
|
||
identityGeneration: "생성",
|
||
identitySeed: "시드",
|
||
identityIncrement: "증가분",
|
||
sqlServerIdentityTypeHint: "SQL Server ID는 tinyint, smallint, int, bigint 및 스케일이 0인 decimal/numeric만 지원합니다",
|
||
},
|
||
diagram: {
|
||
title: "관계 다이어그램",
|
||
open: "다이어그램 보기",
|
||
selectConnection: "연결 선택",
|
||
selectDatabase: "데이터베이스 선택",
|
||
selectSchema: "스키마 선택",
|
||
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: "정상",
|
||
},
|
||
},
|
||
},
|
||
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 값은 이 버전에서 읽기 전용입니다.",
|
||
createMode: "생성 모드",
|
||
createModePersistent: "영구",
|
||
createModeEphemeral: "임시",
|
||
createModePersistentSequential: "영구 순차",
|
||
createModeEphemeralSequential: "임시 순차",
|
||
add: "추가",
|
||
value: "값",
|
||
metadata: "노드 정보",
|
||
prettyJson: "보기 좋게",
|
||
invalidJson: "잘못된 JSON",
|
||
summaryRevision: "수정",
|
||
summaryVersion: "버전",
|
||
summaryLease: "리스",
|
||
summarySize: "크기",
|
||
},
|
||
redis: {
|
||
selectKey: "값을 보려면 키를 선택하세요",
|
||
noKeys: "키가 없습니다",
|
||
noKeysInScanHint: "현재 스캔 범위에 키가 없습니다",
|
||
pattern: "패턴 (예: user:*)",
|
||
fuzzyPattern: "키에 포함된...",
|
||
fuzzyMatch: "퍼지",
|
||
fuzzyMatchTitle: "퍼지 일치: 일반 텍스트 포함으로 키 검색",
|
||
valueSearchPlaceholder: "값에 포함된...",
|
||
allSearchPlaceholder: "키 또는 값에 포함된...",
|
||
searchByKey: "키",
|
||
searchByValue: "값",
|
||
searchByAll: "전체",
|
||
searchFields: "필드와 값 검색",
|
||
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: "만료 없음",
|
||
expiry: "만료",
|
||
expiryNone: "만료 없음",
|
||
expiryTtl: "TTL (초)",
|
||
expiryAt: "만료 시간 (로컬)",
|
||
expiryTtlInvalid: "초 단위의 양의 정수 TTL을 입력하세요",
|
||
expiryDateRequired: "올바른 만료 시간을 선택하세요",
|
||
expiryDatePast: "만료 시간은 미래여야 합니다",
|
||
keyExpiredBeforeDisplay: "표시하기 전에 키가 만료되었습니다.",
|
||
autoRefresh: "자동 새로고침 카운트다운",
|
||
ttlDay: "{count}일",
|
||
columnType: "타입",
|
||
columnKey: "키",
|
||
columnValue: "값",
|
||
columnSize: "크기",
|
||
columnTTL: "TTL",
|
||
binaryStringReadonlyHint: "바이너리 문자열 값은 읽기 전용 모드에서 이스케이프된 텍스트로 표시되며, 원시 바이트 편집은 지원되지 않습니다.",
|
||
selectedKeys: "선택한 키",
|
||
selectAllLoaded: "전체 선택",
|
||
selectAllLoadedTitle: "모든 키 선택 (Ctrl/Cmd+A)",
|
||
deselectAll: "지우기",
|
||
selectLoadedGroupKeys: "로드된 {count}개 일치 키 선택",
|
||
loadedMatchingKeys: "로드된 일치 키 {count}개",
|
||
fuzzyTreeLimit: "{count}개의 퍼지 일치가 브라우저 응답성을 유지하기 위해 평면 목록으로 표시됩니다. 계층 구조를 보려면 검색을 좁히세요.",
|
||
deleteGroup: "그룹 삭제",
|
||
deleteGroupDetails: "{target}\n키 {count}개",
|
||
deleteLoadedSearchKeysDetails: "{target}\n로드된 일치 키 {count}개",
|
||
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: "키 이름을 입력하세요",
|
||
createFieldRequired: "해시 필드를 입력하세요",
|
||
createScoreInvalid: "올바른 점수를 입력하세요",
|
||
jsonModuleNotAvailable: "이 Redis 서버에 ReJSON 모듈이 로드되지 않았습니다",
|
||
fieldRequired: "필드 이름을 입력하세요",
|
||
valueRequired: "값을 입력하세요",
|
||
memberRequired: "멤버를 입력하세요",
|
||
updateAppliedRefreshFailed: "변경 사항은 저장되었지만 값을 새로 고치지 못했습니다: {message}",
|
||
zsetAclCompatibilityWarning: "ACL 호환 모드로 저장했습니다. 동시에 변경된 점수는 확인할 수 없습니다.",
|
||
ttlInvalid: "초 단위의 올바른 TTL을 입력하세요 (만료 없음은 -1)",
|
||
member: "멤버",
|
||
memberDetail: "멤버 상세",
|
||
viewMember: "전체 값 보기",
|
||
copyMember: "멤버 복사",
|
||
copyKeyName: "키 이름 복사",
|
||
copied: "복사했습니다",
|
||
copyInsertStatement: "INSERT 구문 복사",
|
||
copyInsertStatementBinary: "바이너리 데이터에 대한 INSERT 구문을 생성할 수 없습니다",
|
||
editMember: "편집",
|
||
jsonView: "JSON 보기",
|
||
jsonViewRaw: "원본",
|
||
jsonViewDecoded: "디코딩",
|
||
rawContent: "원시 내용",
|
||
wordWrap: "자동 줄바꿈",
|
||
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: "키스페이스",
|
||
},
|
||
},
|
||
},
|
||
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: "정렬...",
|
||
},
|
||
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: "취소",
|
||
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이 편집기에 추가되었습니다. 확인하려면 검토 후 수동으로 실행하세요.",
|
||
},
|
||
sqlParameters: {
|
||
title: "SQL 매개변수",
|
||
description: "SQL 템플릿 자리표시자의 값을 입력하세요. DBX가 SQL을 실행하기 전에 대체합니다.",
|
||
name: "매개변수",
|
||
syntax: "문법",
|
||
type: "유형",
|
||
value: "값",
|
||
valuePlaceholder: "값 입력",
|
||
collectionValuePlaceholder: "JSON 배열 또는 쉼표로 구분된 값 입력",
|
||
preview: "SQL 미리보기",
|
||
execute: "실행",
|
||
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}개 건너뜀",
|
||
dataWriteMode: "데이터 쓰기 모드",
|
||
source: "소스",
|
||
target: "대상",
|
||
sourceConnection: "소스 연결",
|
||
sourceDatabase: "소스 데이터베이스",
|
||
sourceSchema: "소스 스키마",
|
||
targetConnection: "대상 연결",
|
||
targetDatabase: "대상 데이터베이스",
|
||
targetSchema: "대상 스키마",
|
||
tables: "테이블",
|
||
selectAll: "모두 선택",
|
||
deselectAll: "모두 선택 해제",
|
||
createTable: "테이블이 없으면 생성",
|
||
transferMode: "이전 모드",
|
||
modeAppend: "추가 (INSERT)",
|
||
modeOverwrite: "덮어쓰기 (TRUNCATE + INSERT)",
|
||
modeUpsert: "Upsert (PK 기준 INSERT 또는 UPDATE)",
|
||
targetTableNameCase: "대상 테이블 이름 대소문자",
|
||
tableNameCasePreserve: "유지",
|
||
tableNameCaseLower: "소문자",
|
||
tableNameCaseUpper: "대문자",
|
||
batchSize: "배치 크기",
|
||
start: "이전 시작",
|
||
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: "스키마 검색...",
|
||
},
|
||
tableImport: {
|
||
title: "테이블 데이터 가져오기",
|
||
target: "대상 테이블",
|
||
selectFile: "파일 선택",
|
||
changeFile: "파일 변경",
|
||
noFileSelected: "선택한 파일이 없습니다",
|
||
sourceFile: "소스 파일",
|
||
sourceFormat: "소스 형식",
|
||
targetMode: "대상",
|
||
existingTable: "기존 테이블",
|
||
createTable: "테이블 만들기",
|
||
createTableHint: "파일에서 컬럼 추론",
|
||
targetTableName: "테이블 이름",
|
||
noExistingTarget: "선택한 테이블이 없습니다",
|
||
stepSource: "소스",
|
||
stepOptions: "옵션",
|
||
stepMapping: "매핑",
|
||
stepReview: "검토",
|
||
stepExecution: "실행",
|
||
formatCsv: "CSV",
|
||
formatCsvDescription: "쉼표로 구분된 텍스트",
|
||
formatTsv: "TSV",
|
||
formatTsvDescription: "탭으로 구분된 텍스트",
|
||
formatDelimited: "구분자",
|
||
formatDelimitedDescription: "사용자 지정 텍스트 구분자",
|
||
formatJson: "JSON",
|
||
formatJsonDescription: "객체 또는 배열 행",
|
||
formatExcel: "Excel",
|
||
formatExcelDescription: "XLS, XLSX, XLSM",
|
||
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: "가져오기 취소됨",
|
||
},
|
||
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}개 항목",
|
||
copyAllSql: "모든 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: "사용자 지정",
|
||
},
|
||
},
|
||
tableToolbox: {
|
||
title: "데이터 도구",
|
||
generateData: "데이터 생성",
|
||
importData: "데이터 가져오기",
|
||
exportData: "데이터 내보내기",
|
||
generateDataComingSoon: "준비 중",
|
||
},
|
||
sqlFile: {
|
||
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 파일 실행",
|
||
expandAll: "모두 펼치기",
|
||
collapseAll: "모두 접기",
|
||
},
|
||
diff: {
|
||
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: "설정을 삭제했습니다",
|
||
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: "트리거",
|
||
},
|
||
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: "일부 구문은 이미 적용되었고 다른 일부는 실패했을 수 있습니다. 데이터베이스가 불일치 상태일 수 있습니다. 트랜잭션 로그를 검토하고 다시 시도하기 전에 수동으로 조치를 취하세요.",
|
||
},
|
||
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: "컬럼 순서 비교",
|
||
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: "데이터 비교",
|
||
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: "편집기",
|
||
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: "쿼리 사이 줄 수",
|
||
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: "데이터",
|
||
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: "모서리 스타일",
|
||
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: "탭이 여러 행으로 줄바꿈되어 모두 한 번에 표시됩니다.",
|
||
iconTheme: "아이콘 및 로고 스타일",
|
||
iconThemeDefault: "기본",
|
||
iconThemeDefaultDescription: "컬러 DBX 앱 아이콘을 사용합니다.",
|
||
iconThemeBlack: "검정",
|
||
iconThemeBlackDescription: "앱에서 검정 DBX 로고를 사용합니다.",
|
||
iconThemeBlackDescriptionMac: "앱에서 검정 로고를 사용합니다. Dock은 검정 판을 사용하고 메뉴 막대는 시스템을 따릅니다.",
|
||
showTrayIcon: "트레이/메뉴 막대 아이콘 표시",
|
||
showTrayIconDescription: "비활성화하면 아이콘이 표시되지 않지만, 창을 닫아도 이전처럼 DBX가 백그라운드에 숨겨집니다.",
|
||
quitOnClose: "창을 닫을 때 종료",
|
||
quitOnCloseDescription: "활성화하면 닫기 버튼을 클릭할 때 DBX가 트레이에 숨기지 않고 완전히 종료됩니다. 모양 설정에서 나중에 변경할 수 있습니다.",
|
||
closeActionPromptTitle: "창 닫기",
|
||
closeActionPromptDescription: "닫기 버튼을 클릭할 때 수행할 작업을 선택하세요. 설정 > 모양에서 나중에 변경할 수 있습니다.",
|
||
closeActionQuit: "DBX 종료",
|
||
closeActionMinimize: "트레이로 최소화",
|
||
updateNotificationsEnabled: "업데이트 알림 활성화",
|
||
updateNotificationsEnabledDescription: "비활성화하면 DBX가 앱이나 드라이버 업데이트를 자동으로 확인하거나 업데이트 배지를 표시하지 않습니다. 수동 확인은 여전히 가능합니다.",
|
||
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}",
|
||
debugLogsCopy: "로그 복사",
|
||
debugLogsCopied: "복사했습니다",
|
||
debugLogsDownload: "로그 다운로드",
|
||
debugLogsDownloaded: "다운로드했습니다",
|
||
debugLogsClear: "로그 지우기",
|
||
tableStructureSection: "테이블 구조",
|
||
dataGridDisplay: "데이터 그리드 표시",
|
||
tableOpenPageSize: "테이블을 열 때 기본 페이지당 행 수",
|
||
tableOpenPageSizeDescription: "새 테이블을 열 때 페이지당 로드되는 행 수입니다. 테이블에서 페이지당 행을 변경하면 향후 테이블 탭의 기본값이 업데이트됩니다.",
|
||
queryPageSize: "쿼리 결과 기본 페이지당 행 수",
|
||
queryPageSizeDescription: "쿼리 결과 페이지당 로드할 행 수입니다. 최대 {max}행을 지원합니다.",
|
||
queryResultMaxRows: "쿼리 결과 최대 행 수",
|
||
queryResultMaxRowsEnabled: "쿼리 결과 행 수 제한",
|
||
queryResultMaxRowsDescription: "쿼리, 테이블 데이터, 저장 프로시저 및 연속 로딩에서 유지할 총 행 수를 제한합니다.",
|
||
queryResultMaxRowsTooSmall: "쿼리 페이지 크기({pageSize}) 이상이어야 합니다.",
|
||
queryResultMaxRowsUnlimitedDescription: "총 행 수 또는 연속 로딩 수를 제한하지 않습니다. 큰 결과는 많은 메모리를 사용할 수 있습니다.",
|
||
showColumnCommentsInHeader: "이름 아래에 컬럼 주석 표시",
|
||
showColumnCommentsInHeaderDescription: "그리드 컬럼 이름 바로 아래에 테이블 컬럼 주석을 표시합니다.",
|
||
showColumnTypesInHeader: "이름 아래에 컬럼 타입 표시",
|
||
showColumnTypesInHeaderDescription: "그리드 컬럼 이름 바로 아래에 각 컬럼의 데이터 타입을 표시합니다.",
|
||
dataGridShowTransposeFieldMetadata: "전치 보기에 필드 메타데이터 표시",
|
||
dataGridShowTransposeFieldMetadataDescription: "활성화된 데이터 타입과 주석을 전치 보기의 별도 줄에 표시합니다. 활성화하면 행 높이가 증가합니다.",
|
||
colorizeDataGridCellTypes: "데이터 타입별 값 색상 표시",
|
||
colorizeDataGridCellTypesDescription: "테마에 맞는 은은한 텍스트 색상으로 컬럼 데이터 타입에 따라 값을 구분합니다.",
|
||
showIndexIndicatorsInHeader: "컬럼 이름 옆에 인덱스 표시",
|
||
showIndexIndicatorsInHeaderDescription: "그리드 컬럼 헤더에 인덱스 유형을 아이콘으로 표시합니다: 기본키(주황색), 고유 인덱스(빨간색), 일반 인덱스(녹색).",
|
||
compactColumnHeaderActions: "컴팩트한 컬럼 머리글 도구",
|
||
compactColumnHeaderActionsDescription: "포매터와 로컬 필터 도구를 더보기 메뉴로 이동하여 컬럼 이름에 우선순위를 둡니다.",
|
||
dataGridQuickEntry: "빠른 그리드 입력",
|
||
dataGridQuickEntryDescription: "활성화하면 셀을 편집하거나 아래 빈 행을 채운 후 포커스가 벗어나는 즉시 데이터베이스에 저장합니다. 빈번한 입력에 유용하지만 실수로 쓰기를 유발할 수 있습니다.",
|
||
dataGridAutoTransposeSingleRow: "단일 행 쿼리 결과 자동 전치",
|
||
dataGridAutoTransposeSingleRowDescription: "활성화하면 정확히 한 행과 여러 열이 있는 SQL 쿼리 결과가 자동으로 전치 보기로 전환됩니다.",
|
||
infiniteScroll: "무한 스크롤 로딩",
|
||
autoCalculateTotalRows: "전체 행 수 자동 집계",
|
||
autoCalculateTotalRowsDescription: "각 쿼리 후 자동으로 COUNT(*)를 실행하여 일치하는 전체 행 수를 표시합니다. 대규모 쿼리를 빠르게 유지하기 위해 기본적으로 꺼져 있으며, 결과 푸터에서 요청 시 집계할 수 있습니다.",
|
||
infiniteScrollDescription: "목록 하단으로 스크롤할 때 다음 데이터 묶음을 자동으로 불러옵니다.",
|
||
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 파일을 선택합니다.",
|
||
openTabsRestoreMode: "실행 시 탭 복원",
|
||
openTabsRestoreModeDescription: "DBX가 지난번에 열려 있던 탭을 복원하는 방법을 선택하세요.",
|
||
openTabsRestoreModeAll: "모든 탭 유지",
|
||
openTabsRestoreModePinned: "고정 탭만 유지",
|
||
openTabsRestoreModeNone: "탭 유지 안 함",
|
||
openTabsRestoreModeHint: "고정 탭은 탭 바의 왼쪽에 유지되며 빈번한 진입점으로 잘 작동합니다.",
|
||
disconnectTabHandlingMode: "연결 해제 후 탭",
|
||
disconnectTabHandlingModeDescription: "연결이나 데이터베이스를 닫은 후 관련 탭을 처리하는 방법을 선택하세요.",
|
||
disconnectTabHandlingModeCloseTabs: "모든 탭 닫기",
|
||
disconnectTabHandlingModeCloseTabsDescription: "연결이나 데이터베이스의 모든 관련 탭을 닫습니다.",
|
||
disconnectTabHandlingModeKeepTabsClearResults: "객체 탭 닫기, SQL 탭 유지",
|
||
disconnectTabHandlingModeKeepTabsClearResultsDescription: "테이블 데이터, 객체 브라우저, 구조 탭을 닫고 SQL 쿼리 탭과 SQL 텍스트를 유지하며 실행 상태와 결과 세션도 지웁니다.",
|
||
disconnectTabHandlingModeKeepTabsKeepResults: "관련 탭 닫지 않기",
|
||
disconnectTabHandlingModeKeepTabsKeepResultsDescription: "관련 탭, SQL 텍스트, 현재 결과를 추가 정리 없이 유지합니다.",
|
||
reuseDataTab: "데이터 탭 재사용",
|
||
reuseDataTabDescription: "테이블을 열 때 데이터 탭을 사용하는 방식을 선택합니다.",
|
||
dataTabReuseAlwaysNew: "항상 새 탭 열기",
|
||
dataTabReuseAlwaysNewDescription: "테이블이 이미 열려 있어도 매번 새 데이터 탭을 만듭니다.",
|
||
dataTabReuseSameTable: "같은 테이블만 재사용",
|
||
dataTabReuseSameTableDescription: "같은 테이블은 기존 탭으로 전환하고 다른 테이블은 별도로 엽니다.",
|
||
dataTabReuseActiveTab: "활성 데이터 탭 재사용",
|
||
dataTabReuseActiveTabDescription: "안전한 경우 다른 테이블에 활성 데이터 탭을 재사용하며 보호된 탭은 별도로 엽니다.",
|
||
sidebarHiddenTablePrefixes: "숨겨진 테이블 이름 접두사",
|
||
sidebarHiddenTablePrefixesDescription: "한 줄에 하나의 접두사. 사이드바의 테이블, 뷰, 컬렉션 라벨만 줄이며 툴팁과 작업은 전체 이름을 계속 사용합니다.",
|
||
sidebarHiddenTablePrefixesPlaceholder: "예:\nODS_\nT8Y2_LONG_",
|
||
sidebarTablePageSize: "사이드바 페이지 크기",
|
||
sidebarTablePageSizeDescription: "사이드바 트리에서 페이지당 로드되는 최대 테이블/객체 수입니다. 테이블이 많고 페이지를 줄이려면 늘리세요.",
|
||
sidebarTableSearchEnabled: "데이터베이스 내 테이블 검색 활성화",
|
||
sidebarTableSearchEnabledDescription: "확장된 데이터베이스, 스키마 또는 테이블 그룹 아래에 로컬 테이블 검색 상자를 표시하여 각 범위가 독립적으로 테이블을 필터링할 수 있게 합니다.",
|
||
sidebarObjectInfoMode: "사이드바 추가 정보",
|
||
sidebarObjectInfoModeDescription: "이름 뒤에 주석, 객체 크기 또는 추가 텍스트 없음을 선택하세요. 주석과 크기는 상호 배타적입니다. 데이터베이스 합계는 현재 PostgreSQL을 지원하며, 테이블 크기는 MySQL, PostgreSQL, GaussDB, Kingbase, GBase 8a, SQL Server, Oracle, Dameng, ClickHouse를 지원합니다.",
|
||
sidebarObjectInfoModeCommentInline: "주석 (이름 뒤)",
|
||
sidebarObjectInfoModeCommentAligned: "주석 (형제 정렬)",
|
||
sidebarObjectInfoModeCommentRight: "주석 (오른쪽 정렬)",
|
||
sidebarObjectInfoModeSize: "객체 크기",
|
||
sidebarObjectInfoModeHidden: "없음",
|
||
sidebarAllowHorizontalScroll: "사이드바 가로 스크롤 허용",
|
||
sidebarAllowHorizontalScrollDescription: "사이드바 가로 스크롤을 허용하여 긴 테이블, 뷰, 컬렉션 이름을 전체로 표시합니다.",
|
||
snippetsDescription: "편집기에서 트리거되는 SQL 스니펫 템플릿을 사용자 정의합니다.",
|
||
snippetsAdd: "스니펫 추가",
|
||
snippetsLabel: "라벨",
|
||
snippetsPrefix: "접두사",
|
||
snippetsStatus: "상태",
|
||
snippetsEnabled: "활성화됨",
|
||
snippetsDisabled: "비활성화됨",
|
||
snippetsToggle: "스니펫 활성화 또는 비활성화",
|
||
snippetsBody: "SQL 본문",
|
||
snippetsLabelPlaceholder: "예: select *",
|
||
snippetsPrefixPlaceholder: "예: sel",
|
||
snippetsBodyPlaceholder: "SELECT *\nFROM table\nLIMIT 100;",
|
||
snippetsRestoreDefaults: "기본값 복원",
|
||
snippetsAddTitle: "스니펫 추가",
|
||
snippetsEditTitle: "스니펫 편집",
|
||
syncWebDavTitle: "WebDAV 동기화",
|
||
syncWebDavDescription: "WebDAV 호환 저장 서비스에서 DBX 스냅샷을 업로드하거나 복원합니다(저장된 SQL 라이브러리 항목 포함).",
|
||
syncEndpoint: "WebDAV URL",
|
||
syncUsername: "사용자 이름",
|
||
syncPassword: "비밀번호",
|
||
syncPasswordPlaceholder: "비밀번호 입력",
|
||
syncClearSavedPassword: "저장된 비밀번호 지우기",
|
||
syncRememberWebDavPassword: "WebDAV 앱 비밀번호 기억",
|
||
syncSavedPassword: "(저장됨)",
|
||
syncRememberWebDavPasswordDescription: "비밀번호는 이 기기에만 암호화되어 저장됩니다. 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: "실행 모드 (Cmd+Enter)",
|
||
executeModeAll: "모든 SQL 실행",
|
||
executeModeCurrent: "커서 위치의 구문 실행",
|
||
executeAllOnBlankLine: "빈 줄에서 모든 SQL 실행",
|
||
executeAllOnBlankLineDescription: "현재 구문 실행 모드에서 커서 위치에 구문이 없으면 모든 SQL을 실행합니다. 기본적으로 비활성화됩니다.",
|
||
showExecutionTargetPicker: "실행 대상 선택기 표시",
|
||
showExecutionTargetPickerDescription: "활성화하면 선택 없이 실행할 때 현재 구문과 전체 SQL 중에서 선택할 수 있습니다.",
|
||
showStatementRunButtons: "왼쪽 실행 버튼 표시",
|
||
showStatementRunButtonsDescription: "SQL 편집기 여백에 구문별 실행 버튼을 표시합니다. 비활성화해도 키보드 단축키와 컨텍스트 메뉴 실행은 계속 작동합니다.",
|
||
showCurrentStatementFrame: "현재 구문 프레임 표시",
|
||
showCurrentStatementFrameDescription: "활성화하면 SQL 편집기가 현재 실행 가능한 구문 주위에 윤곽선을 그립니다. 비활성화하면 윤곽선이 숨겨집니다.",
|
||
showInsertValueHints: "INSERT 값 컬럼 힌트 표시",
|
||
showInsertValueHintsDescription: "활성화하면 SQL 편집기가 INSERT ... VALUES 절의 각 값 옆에 컬럼 이름 힌트를 표시합니다.",
|
||
previewStatementRunButton: "구문 실행 버튼 미리보기",
|
||
wordWrap: "자동 줄바꿈",
|
||
wordWrapDescription: "편집기 너비 내에서 긴 줄을 줄바꿈합니다",
|
||
vimMode: "Vim 모드",
|
||
vimModeDescription: "SQL 편집기에서 Vim 스타일의 모달 편집을 사용합니다",
|
||
autoCloseBrackets: "괄호 자동 닫기",
|
||
autoCloseBracketsDescription: "여는 괄호나 따옴표를 입력할 때 닫는 괄호와 따옴표를 자동으로 삽입합니다",
|
||
insertSpaceAfterCompletion: "완성 후 공백 삽입",
|
||
insertSpaceAfterCompletionDescription: "다음 문자가 허용할 때 키워드, 테이블 또는 컬럼 완성을 수락한 후 공백을 추가합니다",
|
||
completionTriggerMode: "자동 완성 트리거 모드",
|
||
completionTriggerModeDescription: "SQL 완성 팝업이 자동으로 열리는 시기를 제어합니다. 수동은 단축키 필요; 입력 식별자는 하나 이상의 문자 입력 필요; 스마트 위치는 현재 동작 유지.",
|
||
completionTriggerModeManual: "수동만",
|
||
completionTriggerModeRequirePrefix: "식별자 입력 후",
|
||
completionTriggerModePositional: "스마트 위치",
|
||
sqlSemanticDiagnosticsEnabled: "SQL 의미 진단",
|
||
sqlSemanticDiagnosticsEnabledDescription: "활성화하면 편집기가 알 수 없는 테이블과 컬럼 같은 의미 문제를 보고합니다. 대규모 SQL의 파싱과 메타데이터 검사를 줄이려면 비활성화하세요.",
|
||
confirmDangerousSqlExecution: "위험한 작업 전에 확인",
|
||
confirmDangerousSqlExecutionDescription: "비활성화하면 위험한 SQL과 테이블 행 또는 문서 삭제가 경고 대화상자 없이 실행됩니다.",
|
||
continueOnErrorOnBatch: "오류 시 계속",
|
||
continueOnErrorOnBatchDescription: "활성화하면 다중 구문 실행이 첫 번째 실패에서 중지하는 대신 오류 후에도 계속됩니다.",
|
||
confirmUnsavedSqlClose: "저장되지 않은 SQL 닫기 전 확인",
|
||
confirmUnsavedSqlCloseDescription: "비활성화하면 저장되지 않은 편집이 있는 SQL 탭이 저장 확인 대화상자 없이 닫히거나 종료됩니다.",
|
||
savedSqlOpenTarget: "저장된 SQL의 기본 실행 대상",
|
||
savedSqlOpenTargetSaved: "저장된 대상",
|
||
savedSqlOpenTargetSavedDescription: "SQL 파일에 저장된 연결, 데이터베이스 및 스키마를 사용합니다.",
|
||
savedSqlOpenTargetCurrent: "현재 탭",
|
||
savedSqlOpenTargetCurrentDescription: "가능한 경우 현재 탭의 연결, 데이터베이스, 스키마 및 카탈로그를 사용하고, 그렇지 않으면 저장된 대상을 사용합니다.",
|
||
prefillNewQueryWithSelect: "새 쿼리에 SELECT * 미리 채우기",
|
||
prefillNewQueryWithSelectDescription: "새 쿼리를 만들 때 활성 테이블 탭이나 사이드바에서 선택한 테이블을 기반으로 편집기에 SELECT * FROM <table>을 미리 채웁니다.",
|
||
sqlVariableSyntax: "SQL 변수 및 자리표시자 치환",
|
||
sqlVariableSyntaxDescription: "데이터베이스 유형별로 SQL을 실행하기 전에 DBX가 치환할 변수와 자리표시자 문법을 선택하세요. 모두 기본적으로 활성화됩니다.",
|
||
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 같은 생성된 별칭을 삽입합니다.",
|
||
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: "내보내기",
|
||
shortcutExecuteSql: "SQL 실행",
|
||
shortcutExecuteSqlInNewResultTab: "새 결과 탭에서 SQL 실행",
|
||
shortcutFind: "찾기",
|
||
shortcutReplace: "바꾸기",
|
||
shortcutSaveSql: "SQL 저장",
|
||
shortcutAcceptCompletion: "완성 수락",
|
||
shortcutFormatSql: "SQL 서식",
|
||
shortcutExpandSelectStar: "*을(를) 열로 확장",
|
||
shortcutToggleLineComment: "줄 주석 전환",
|
||
shortcutIndentMore: "들여쓰기 늘리기",
|
||
shortcutIndentLess: "들여쓰기 줄이기",
|
||
shortcutInsertLineBelow: "아래에 줄 삽입",
|
||
shortcutDuplicateLine: "현재 줄 복제",
|
||
shortcutDeleteLine: "현재 줄 삭제",
|
||
shortcutMoveLineUp: "줄 위로 이동",
|
||
shortcutMoveLineDown: "줄 아래로 이동",
|
||
shortcutCopyLineUp: "줄 위로 복사",
|
||
shortcutCopyLineDown: "줄 아래로 복사",
|
||
shortcutUndo: "실행 취소",
|
||
shortcutRedo: "다시 실행",
|
||
shortcutSelectAll: "모두 선택",
|
||
shortcutCopyCurrentRow: "현재 데이터 행 복사",
|
||
shortcutDeleteCurrentRow: "현재 데이터 행 삭제",
|
||
shortcutNewQuery: "새 쿼리",
|
||
shortcutOpenSettings: "설정 열기",
|
||
shortcutCloseTab: "탭 닫기",
|
||
shortcutFocusSearch: "현재 화면 검색에 포커스",
|
||
shortcutQuickOpen: "빠른 열기 (모든 데이터베이스 객체 검색)",
|
||
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: "데이터 새로고침",
|
||
shortcutToggleTranspose: "전치 보기 전환",
|
||
shortcutCancelSearch: "검색 취소",
|
||
shortcutToggleSidebar: "사이드바 전환",
|
||
shortcutCopySidebarSelection: "사이드바 선택 복사",
|
||
shortcutPasteSidebarSelection: "사이드바에 붙여넣기",
|
||
shortcutEditSidebarConnection: "사이드바 연결 편집",
|
||
shortcutOpenDataInNewTab: "새 탭에서 데이터 열기 (마우스 클릭)",
|
||
shortcutViewTableDdl: "테이블 DDL 보기",
|
||
shortcutSendSelectionToAi: "선택 영역을 AI로 보내기",
|
||
shortcutSqlIntentionActions: "SQL 인텐트 동작 (* 펼치기 / 식별자 한정)",
|
||
intentionExpandWildcard: "* 을(를) 열 목록으로 펼치기",
|
||
intentionQualifyIdentifier: "식별자 한정",
|
||
intentionUnqualifyIdentifier: "한정 해제",
|
||
intentionBatchQualifyIdentifiers: "식별자 일괄 한정",
|
||
shortcutScopeGlobal: "전역",
|
||
shortcutScopeEditor: "SQL 편집기",
|
||
shortcutScopeGrid: "데이터 그리드",
|
||
shortcutScopeSearch: "필드 검색",
|
||
shortcutScopeSidebar: "사이드바",
|
||
shortcutPressShortcut: "단축키를 누르세요",
|
||
shortcutSearchPlaceholder: "단축키 검색",
|
||
shortcutSearchNoResults: "검색과 일치하는 단축키가 없습니다.",
|
||
shortcutConflict: "이 단축키는 같은 범위의 다른 작업과 충돌합니다.",
|
||
shortcutClear: "단축키 지우기",
|
||
preview: "실시간 미리보기",
|
||
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을 사용할 수 있습니다.",
|
||
mcpCursorConfigPath: "Cursor는 프로젝트의 .cursor/mcp.json 또는 전역 ~/.cursor/mcp.json을 사용할 수 있습니다.",
|
||
mcpTraeConfigPath: "TRAE: 설정 > 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: "DBX가 모든 MCP 클라이언트에 적용하는 권한 수준을 선택하세요. 클라이언트 측 읽기/쓰기 설정으로 이 수준을 변경할 수 없습니다.",
|
||
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: "차단됨",
|
||
mcpCapabilityAlwaysEnforced: "모든 모드는 연결 허용 목록, 연결 읽기 전용 보호, 프로덕션 보호 및 데이터베이스 계정 권한의 적용을 받습니다.",
|
||
mcpPolicySaveFailed: "MCP 접근 정책 저장 실패: {error}",
|
||
mcpPolicyLoadFailed: "MCP 접근 정책 불러오기 실패: {error}",
|
||
mcpDetectionTiming: "DBX는 이 페이지를 열 때 자동으로 확인합니다. 새로고침하려면 다시 확인을 사용하세요.",
|
||
mcpNpmBoundary: "DBX는 MCP 상태를 확인하고 설명만 합니다. 설치와 업그레이드는 여전히 npm을 통해 실행됩니다.",
|
||
mcpRefresh: "다시 확인",
|
||
mcpGuide: "MCP 가이드",
|
||
supportInfoTitle: "지원 정보",
|
||
supportInfoDescription: "이슈를 등록하거나 도움을 요청할 때 이 환경 세부 정보를 복사하세요.",
|
||
supportInfoCopy: "지원 정보 복사",
|
||
supportInfoCopied: "복사했습니다",
|
||
supportInfoLoading: "지원 정보를 불러오는 중...",
|
||
supportInfoLoadFailed: "전체 지원 정보를 불러오는 데 실패했습니다: {message}",
|
||
supportInfoAppVersion: "DBX 버전",
|
||
supportInfoRuntime: "런타임",
|
||
supportInfoRuntimeDesktop: "데스크톱",
|
||
supportInfoRuntimeWeb: "웹",
|
||
supportInfoOperatingSystem: "운영 체제",
|
||
supportInfoArchitecture: "아키텍처",
|
||
supportInfoUnknown: "알 수 없음",
|
||
community: "커뮤니티",
|
||
qqGroup: "QQ 그룹",
|
||
wechatGroup: "위챗 그룹",
|
||
wechatGroupInvite: "텐센트 문서 초대",
|
||
project: "프로젝트",
|
||
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 조건으로 붙여넣기",
|
||
},
|
||
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}개 설치.",
|
||
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: "오프라인 패키지 가져오기",
|
||
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: "로컬 설치",
|
||
runtimeDrivers: "런타임",
|
||
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: "뷰 / 프로시저 / 함수 / 시퀀스",
|
||
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}개를 성공적으로 내보냈습니다",
|
||
allDatabasesTask: "모든 데이터베이스 ({count})",
|
||
exportError: "내보내기 실패: {error}",
|
||
exportCancelled: "내보내기 취소됨",
|
||
runInBackground: "백그라운드에서 실행",
|
||
},
|
||
databaseBackup: {
|
||
title: "데이터베이스 백업",
|
||
schedules: "백업 일정",
|
||
runtimeRequirement: "예약된 백업은 DBX가 열려 있는 동안(트레이에 최소화된 경우 포함) 실행됩니다.",
|
||
addSchedule: "일정 추가",
|
||
noSupportedConnections: "백업 일정을 추가하려면 먼저 MySQL 또는 PostgreSQL 연결을 만들어 주세요.",
|
||
editSchedule: "일정 편집",
|
||
defaultScheduleName: "데이터베이스 백업",
|
||
noSchedules: "백업 일정이 없습니다",
|
||
scheduleName: "일정 이름",
|
||
connection: "연결",
|
||
missingConnection: "연결 누락",
|
||
destination: "대상 디렉터리",
|
||
selectDestination: "백업 디렉터리 선택",
|
||
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}개를 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.",
|
||
backupDeleted: "백업을 삭제했습니다",
|
||
runSuccess: "백업 완료 (파일 {count}개)",
|
||
runCancelled: "백업 취소됨",
|
||
runFailed: "백업 실패: {error}",
|
||
unknownError: "알 수 없는 오류",
|
||
status: {
|
||
running: "실행 중",
|
||
success: "완료",
|
||
failed: "실패",
|
||
cancelled: "취소됨",
|
||
},
|
||
weekdays: {
|
||
sunday: "일요일",
|
||
monday: "월요일",
|
||
tuesday: "화요일",
|
||
wednesday: "수요일",
|
||
thursday: "목요일",
|
||
friday: "금요일",
|
||
saturday: "토요일",
|
||
},
|
||
},
|
||
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: "메시지",
|
||
},
|
||
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: "구독",
|
||
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: "오프셋부터 읽기",
|
||
kafkaLatestHint: "각 파티션 끝 부근에서 균등하게 읽고 타임스탬프 내림차순으로 병합합니다.",
|
||
kafkaEarliestHint: "선택한 각 파티션의 처음부터 오름차순으로 읽습니다.",
|
||
kafkaOffsetHint: "지정한 오프셋부터 선택한 파티션(비워 두면 전체)을 오름차순으로 읽습니다.",
|
||
messagesLoading: "메시지를 불러오는 중...",
|
||
noMessages: "메시지가 없습니다",
|
||
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}",
|
||
},
|
||
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: {
|
||
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: "네임스페이스 편집",
|
||
creatingNamespace: "만드는 중...",
|
||
updatingNamespace: "업데이트 중...",
|
||
namespaceCreated: '네임스페이스 "{name}" 생성됨',
|
||
namespaceUpdated: '네임스페이스 "{name}" 업데이트됨',
|
||
namespaceId: "네임스페이스 ID",
|
||
namespaceIdPlaceholder: "Nacos가 자동 생성하려면 비워 두세요",
|
||
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: "다른 네임스페이스 선택",
|
||
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: "게시",
|
||
dataIdRequired: "데이터 ID는 필수입니다",
|
||
allGroups: "모든 그룹",
|
||
noConfigs: "구성이 없습니다",
|
||
selectConfig: "구성을 선택하거나 만드세요",
|
||
noServices: "서비스가 없습니다",
|
||
selectService: "서비스를 선택하세요",
|
||
service: "서비스",
|
||
instances: "인스턴스",
|
||
instanceCount: "인스턴스 {count}개",
|
||
refresh: "새로고침",
|
||
address: "주소",
|
||
cluster: "클러스터",
|
||
weight: "가중치",
|
||
state: "상태",
|
||
actions: "작업",
|
||
query: "쿼리",
|
||
body: "본문",
|
||
response: "응답",
|
||
template: "템플릿",
|
||
configDiffTitle: "구성 내용 비교",
|
||
inlineCompare: "인라인 비교",
|
||
currentVersionContent: "현재 공식 버전:",
|
||
publishVersionContent: "이번 릴리스 내용:",
|
||
confirmSaveTitle: "Nacos 구성 변경 검토",
|
||
confirmSaveMessage: "이 구성 변경을 저장하시겠습니까? +{added} / -{removed}줄 변경.",
|
||
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 버전을 선택합니다.",
|
||
nacosServiceAddress: "서비스 주소",
|
||
nacosServiceAddressHint: "서비스 주소를 입력하세요. 기본 포트는 8848입니다(예: http://host:8848/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)를 사용하세요.",
|
||
nacosAdvancedTitle: "Nacos 고급 연결 옵션",
|
||
nacosAdvancedDescription: "안전한 기본값이 적용되어 있으며, 사용자 지정 배포·메트릭·r-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: "메타데이터",
|
||
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: "등록 해제",
|
||
},
|
||
});
|