이 페이지의 내용
문서API 레퍼런스
API 레퍼런스05

MetaView

참조 컬럼으로 데이터를 구성하고 입출력을 관리합니다.

한국어 문서약 49분

MetaView는 데이터를 컬럼(column) 과 행(row) 으로 구성하는 객체입니다.

명령(BindCommand) 객체의 valid, bind, output, misc 속성에서 사용됩니다.

MetaView와 MetaTable 과의 차이점#

MetaTable은 독립 데이터 관리에 초점을 맞춘 구조로 설계되었습니다. 데이터 변경을 효과적으로 처리하기 위해 트랜잭션 관련 메서드(acceptChanges(), rejectChanges(), getChanges())를 제공하여 데이터의 상태를 추적하고 변경 사항을 관리할 수 있습니다.

반면, MetaView는 참조 관리가 가능한 구조적 차별점을 가지고 있습니다. columns 컬렉션에 컬럼의 참조값을 등록할 수 있어 동일한 데이터를 여러 뷰에서 공유하거나, 필요에 따라 독립적으로 처리할 수 있는 유연성을 제공합니다.

구성 요소#

속성#

항목 설명
_baseEntity 컬럼을 추가 시 기준이 될 엔티티를 지정합니다.
viewName MetaView 이름을 나타냅니다.
columns 컬럼을 정의하는 컬렉션입니다.
rows 데이터를 행(Row) 단위로 관리하는 컬렉션입니다.

메소드#

항목 설명
clone() 객체를 복제하여 새로운 객체를 생성합니다.
copy() 특정 조건에 만족하는 컬럼 구조의 데이터를 복사합니다.
clear() rows 컬렉션의 데이터를 초기화합니다.
reset() columns 컬렉션과 rows 컬렉션을 초기화합니다.
newRow() 컬럼 구조에 맞는 새로운 데이터 행(row)을 생성합니다.
getValue() 현재 컬럼값(value)을 기반으로 데이터(row)를 반환합니다.
setValue() 컬럼 값(value)을 지정된 데이터(row)로 설정합니다.
merge() 다른 MetaView 객체의 데이터를 현재 객체에 병합합니다.
select() 조건에 맞는 행을 필터링하거나 특정 컬럼 데이터를 반환합니다.
output() 데이터를 직렬화된 문자열 또는 특정 형식으로 내보냅니다.
load() 직렬화된 객체를 로드하여 컬럼과 행 데이터를 구성합니다.
write() 현재 객체를 스키마 타입의 객체로 변환하여 반환합니다.
writeSchema() 현재 객체의 컬럼 정보를 스키마 타입의 객체로 변환하여 반환합니다.
writeData() 현재 객체의 행(데이터)을 스키마 타입의 객체로 변환하여 반환합니다.
read() MetaView 스키마 타입 객체를 읽어옵니다.
readSchema() MetaView 스키마 타입 객체의 컬럼(구조) 정보를 읽어옵니다.
readData() MetaView 스키마 타입 객체의 행(데이터) 정보를 읽어옵니다.

데이터 입출력 메서드 정리#

InPut 설명 OutPut 설명
load(str) 직렬화(문자열) 불러오기 output(): str 직렬화(문자열) 내보내기
read(obj) 읽기 (스키마 + 데이터) write(): obj 쓰기 (스키마 + 데이터)
readSchema(obj) 스키마 읽기 writeSchema(): obj 스키마 쓰기
readData(obj) 데이터 읽기 writeData(): obj 데이터 쓰기

주요 속성#

_baseEntity#

컬럼을 추가 시 기준이 될 엔티티를 지정하는 속성입니다.

ts
type _baseEntity = MetaTable | MetaView;

_baseEntity 속성을 설정한 후 컬럼을 추가하면, 지정된 엔티티에 컬럼이 등록되며, 현재 객체에는 해당 컬럼을 참조하는 컬럼이 등록됩니다.

  • 참조 컬럼 방식: _baseEntity을 지정한 경우, 추가된 컬럼은 참조값이 등록됩니다.
  • 독립 컬럼 방식: _baseEntity 을 지정하지 않으면, 컬럼이 뷰에 독립적으로 생성됩니다.

전체 참조 예제

js
const table1 = new MetaTable('t1');
const view1 = new MetaView('v1');

// 기본 엔티티 설정
view1._baseEntity = table1;

view1.columns.add('u_id');
view1.columns.add('addr');

view1.columns['u_id'] === table1.columns['u_id'] // true
view1.columns['addr'] === table1.columns['addr'] // true
  • view1 추가된 컬럼(id, addr)은 table1에 컬럼이 추가되고, 참조값이 view1에 등록됩니다.

특정 컬럼만 참조 예제

js
const table1 = new MetaTable('t1');
const view1 = new MetaView('v1');

view1.columns.add('u_id', table1.columns);  // 컬럼 추가 시 컬렉션 지정
view1.columns.add('addr');

view1.columns['u_id'] === table1.columns['u_id'] // true
console.log(view1.columns['addr']);              // [Object MetaColumn]
  • view1에 u_id 컬럼은 참조로 등록되고, addr 컬럼은 독립적으로 추가됩니다.

HTMLColumn 은 MetaColumn 의 자식 클래스 입니다.

독립 사용 예제

js
const view1 = new MetaView('v1');

view1.columns.addValue('addr', 'USA');

console.log(view1.columns['addr'].value); // Out: 'USA'
  • view1에 addr 컬럼을 독립적으로 추가합니다.

viewName#

MetaView 이름을 나타내는 속성입니다.

ts
type viewName = string;
  • string: 뷰 이름 문자열

Tip : _name 속성과 동일한 값을 가집니다.

viewName 속성은 MetaView의 이름을 나타내며, 이를 통해 객체를 식별하고 관리할 수 있습니다.

  • viewName 속성을 변경하면 상위 속성인 _name 도 함께 변경됩니다.
js
const view1 = new MetaView('v1');

console.log(view1.viewName); // Out: 'v1'
console.log(view1._name);    // Out: 'v1'

view1.viewName = 'v2';  // 이름 변경

console.log(view1.viewName); // Out: 'v2'
console.log(view1._name);    // Out: 'v2'
  • viewName 속성을 업데이트합니다.

columns 또는 cols#

컬럼을 정의하는 컬렉션 속성입니다.

별칭으로 cols 속성을 제공합니다.

ts
type columns = MetaViewColumnCollection;
  • MetaViewColumnCollection: MetaColumn 객체 컬렉션

참조 : MetaViewColumnCollection API

columns 속성은 컬럼을 정의하는 컬렉션으로, add() 메서드를 사용하여 컬럼을 등록하거나 컬렉션을 제어할 수 있습니다.

  • 정의된 컬럼에 따라 행(row)의 구조가 결정됩니다.
  • 등록되는 컬럼은 독립적으로 생성되거나 참조값을 가질 수 있습니다.

컬럼 추가 예제

js
const view1 = new MetaView('v1');

// 빈 컬럼 추가
view1.columns.add('u_id');

// 초기값이 있는 컬럼 추가
view1.columns.addValue('addr', 'USA');

console.log(view1.columns['u_id']);         // [Object MetaColumn]
console.log(view1.columns['addr'].value);   // 'USA'
  • add() 메서드를 사용하여 빈 컬럼을 추가합니다.
  • addValue() 메서드를 사용하여 초기값이 있는 컬럼을 추가합니다.

BindModel 에서 컬럼 추가 예제

js
const bm = new BindModel();

// 기본 컬렉션에서 컬럼 추가
bm.columns.add('gender');
bm.columns.addValue('addr', 'USA');

// 모델에서 컬럼 추가
bm.addColumn('memo');
bm.addColumnValue('age', 20);

console.log(view1.columns['gender']);       // [Object MetaColumn]
console.log(view1.columns['addr'].value);   // Out: 'USA'
console.log(view1.columns['memo']);         // [Object MetaColumn]
console.log(view1.columns['age'].value);    // Out: 20
  • columns 컬렉션을 사용하거나 addColumn() addColumnValue() 메소드를 통해 컬럼을 추가할 수 있습니다.

컬럼 참조 사용 예제

js
const table1 = new MetaTable('t1');
const view1 = new MetaView('v1');

view1.columns.add('u_name', table1.columns);  // 컬럼 추가 시 컬렉션 지정
view1.columns.add('addr');

view1.columns['u_name'] === table1.columns['u_name'] // true
console.log(view1.columns['addr']);                  // [Object MetaColumn]

  • view1에 u_name 컬럼은 참조로 등록되고, addr 컬럼은 독립적으로 추가됩니다.

참조 : HTMLColumn API


rows#

데이터를 행(Row) 단위로 관리하는 컬렉션 속성입니다.

ts
type rows = MetaRowCollection;
  • MetaRowCollection: 행 객체들의 컬렉션

rows 컬렉션은 뷰의 데이터를 관리하는 데 사용되며, 각 행은 개별 컬럼 데이터를 포함합니다.

  • 컬렉션의 add() 메소드를 사용하여 행(row)을 추가할 수 있습니다.
  • 행(row)을 추가한 후에는 컬럼을 추가하거나 제거할 수 없습니다. (제약조건)
js
const view1 = new MetaView('v1');

// 컬럼 추가
view1.columns.add('u_name');
view1.columns.add('age');

// 행 추가
const row = view1.newRow();
row['u_name'] = 'John';
row['age'] = 20;
view1.rows.add(row);

console.log(view1.rows[0]['u_name']); // Out: 'John'
console.log(view1.rows[0]['age']);    // Out: 20
  • newRow() 메서드를 사용하여 새로운 행을 생성하고, 데이터를 설정합니다.
  • 생성된 행을 rows 컬렉션에 add() 메서드를 통해 추가합니다.

주요 메소드#

clone()#

객체를 복제하여 새로운 객체를 생성하는 메서드입니다.

ts
declare function clone(): MetaView;
  • 반환값: 복제된 새로운 MetaView 객체

clone() 메서드는 객체의 현재 상태를 그대로 복제하여 새로운 MetaView 객체를 생성합니다. 복제된 객체는 원본과 독립적으로 동작하며, 동일한 속성을 유지합니다.

js
const view1 = new MetaView('v1');

view1.columns.addValue('age', 20);

// 뷰 복제
const clone = view1.clone();

consol.log(clone.viewName);  // Out: 'v1'
clone.columns['age'] === view1.columns['age']             // false
clone.columns['age'].value === view1.columns['age'].value // true
  • 복제된 객체는 원본과 독립적으로 동작하며, 동일한 구조와 속성을 가집니다.

copy()#

특정 조건에 만족하는 컬럼 구조의 데이터를 복사하는 메서드입니다.

ts
declare function copy(
    filter: (row, idx, view) => boolean | string[] | arguments<string>, 
    colNames?: string[] | arguments<string>
): MetaView;
  • filter: 필터 콜백함수 또는 대상 컬럼명
    1. 함수: 행(row), 인덱스(idx), 원본 뷰(view)를 매개변수로 받아 boolean 타입을 반환합니다.
    2. string[]: 특정 컬럼명만 복사합니다.
    3. arguments<string>: 매개변수 형태로 전달된 컬럼명을 복사합니다.
  • colNames(선택): 복사 대상의 컬럼명 또는 컬럼 문자열 배열 또는 arguments<string> 형태
  • 반환값: 데이터를 복사한 새로운 MetaView 객체를 반환합니다.

copy() 메서드는 현재 객체에서 특정 조건에 만족하는 컬럼과 데이터를 복사하여 새로운 객체로 반환합니다.

  • 컬럼명을 배열 또는 인자로 전달하여 복사할 대상 컬럼을 지정할 수 있습니다.
  • filter 함수를 사용하여 조건에 만족하는 행(row)을 선택할 수 있습니다.
js
const view1 = new MetaView('view1');

// 컬럼 추가
view1.columns.add('c1');
view1.columns.add('c2');
view1.columns.add('c3');

// 행 추가 
view1.rows.add(view1.newRow());
view1.rows[0]['c1'] = 1;
view1.rows[0]['c2'] = 2;
view1.rows[0]['c3'] = 3;
view1.rows.add(view1.newRow());
view1.rows[1]['c1'] = 10;
view1.rows[1]['c2'] = 20;
view1.rows[1]['c3'] = 30;

// 첫번째 복사
const copy1 = view1.copy(row => row['c1'] < 10, ['c1']);

console.log(copy1.rows.count);    // Out: 1
console.log(copy1.rows[0]['c1']); // Out: 1

// 두번째 복사
const copy2 = view1.copy(['c1', 'c2']);

console.log(copy2.rows[0]['c1']); // Out: 1
console.log(copy2.rows[0]['c2']); // Out: 2
console.log(copy2.rows[1]['c1']); // Out: 10
console.log(copy2.rows[1]['c2']); // Out: 20
  • 첫번째 copy1 뷰에는 c1 값이 10보다 작은 특정 컬럼('c1'])만 복사합니다.
  • 두번째 copy2 뷰에는 특정 컬럼(['c1', 'c2'])만 복사합니다.

clear()#

rows 컬렉션의 데이터를 초기화하는 메서드입니다.

ts
declare function clear(): void;

• 반환값: 없음

clear() 메서드는 모든 행(row) 데이터를 초기화하며, 컬럼 정의는 유지합니다.

js
const view = new MetaView('v1');

// 컬럼 추가
view.columns.add('age');
view.columns.add('u_name');

// 데이터(행) 추가
view.rows.add(view.newRow());
view.rows[0].age = 10;
view.rows[0].u_name = 'Alice';
view.rows.add(view.newRow());
view.rows[1].age = 20;
view.rows[1].u_name = 'Bob';

console.log(view.rows.count);    // Out: 2

// 데이터 초기화
view.clear();

console.log(view.rows.count);    // Out: 0
console.log(view.columns.count); // Out: 2
  • clear()를 호출하면 컬럼 정의는 유지되며, 모든 데이터만 초기화됩니다.

reset()#

columns 컬렉션과 rows 컬렉션을 초기화하는 메서드입니다.

ts
declare function reset(): void;

reset() 메서드는 MetaView 객체의 컬럼과 데이터 행(row)을 초기 상태로 재설정하여 구조와 데이터를 모두 삭제합니다.

js
const view = new MetaView('v1');

// 컬럼 추가
view.columns.add('age');
view.columns.add('u_name');

// 데이터(행) 추가
view.rows.add(view.newRow());
view.rows[0].age = 10;
view.rows[0].u_name = 'Alice';

// 전체 초기화
view.reset();

console.log(view.viewName);      // Out: 'v1'
console.log(view.rows.count);    // Out: 0
console.log(view.columns.count); // Out: 0
  • reset() 메서드를 호출하여 컬럼 정의와 데이터 행(rows)을 모두 초기화합니다.

newRow()#

컬럼 구조에 맞는 새로운 데이터 행(row)을 생성하는 메서드입니다.

ts
declare function newRow(): MetaRow;
  • 반환값: 생성된 빈 데이터 행(MetaRow) 객체

newRow() 메서드는 MetaView 객체의 컬럼 정의를 기반으로 초기화된 새로운 데이터 행을 반환합니다.

  • 각 행의 초기값은 개별 컬럼의 default 속성값을 가집니다. (초기값)
  • 컬럼에 alias 속성이 지정되어 있으면, 별칭이 행(row)의 키로 구성됩니다.
js
const view = new MetaView('v1');

// 컬럼 추가
view.columns.add('id');
view.columns.add('name');

// 데이터(행) 추가
const row = view.newRow();
row['age'] = 20;
row['u_name'] = 'Alice';
view.rows.add(row);

console.log(view.rows[0]['age']);    // Out: 20
console.log(view.rows[0]['u_name']); // Out: 'Alice'
  • newRow() 메서드로 생성된 행은 컬럼 이름을 키로 가지며, default 값으로 초기화됩니다.
  • 생성된 데이터 행(row)은 rows 컬렉션에 추가할 수 있습니다.

getValue()#

현재 컬럼값(value)을 기반으로 데이터(row)를 반환하는 메서드입니다.

ts
declare function getValue(): MetaRow;
  • 반환값: 현재 컬럼 값이 포함된 데이터 행(MetaRow) 객체

getValue() 메서드는 모든 컬럼 값(value)을 포함하는 하나의 데이터 행(row)을 반환합니다.

  • 컬럼에 alias 속성이 지정되어 있으면, 별칭이 행의 키로 구성되어 value 속성값을 포함합니다.
  • 컬럼값(value)이 설정되지 않은 경우, default 속성값을 가집니다.

Tip: setValue() 메소드를 사용하여 데이터(row)를 컬럼 값(value)으로 설정할 수 있습니다.

js
const view = new MetaView('v1');

// 컬럼 추가
view.columns.addValue('age', 20);
view.columns.add('u_name');

const row = view.getValue();

console.log(row['age']);    // Out: 20
console.log(row['u_name']); // Out: ''
  • getValue() 메서드는 현재 컬럼 값(value)으로 구성된 데이터 행을 반환합니다.
  • 설정되지 않은 u_name 컬럼은 default 속성값을 가집니다. (default 기본값은 공백)

setValue()#

컬럼 값(value)을 지정된 데이터(row)로 설정하는 메서드입니다.

ts
declare function setValue(row: MetaRow): void;
  • row: 설정할 데이터가 포함된 MetaRow 객체

setValue() 메서드는 데이터 행(row)을 사용하여 컬럼 값(value)을 설정합니다.

  • 행(row)의 키는 컬럼 이름에 매칭하여, alias 속성이 설정된 경우 이를 우선적으로 적용합니다.
  • 다른 엔티티의 행(row)인 경우에도 컬럼명 매칭 기준에 따라 컬럼 값을 가져올 수 있습니다.
js
const view = new MetaView('v1');

// 컬럼 추가
view.columns.add('age');
view.columns.add('u_name');
view.columns['u_name'].alias = 'r_name';  // 별칭 설정

// 행 생성
const row = view.newRow();
row['age'] = 20;
row['r_name'] = 'Alice';

// 컬럼값 설정
view.setValue(row);

// 행 추가
view.rows.add(row);

console.log(view.columns['age'].value);    // Out: 20
console.log(view.columns['u_name'].value); // Out: 'Alice'
console.log(view.rows[0]['age']);          // Out: 20
console.log(view.rows[0]['r_name']);       // Out: 'Alice'
  • setValue() 메서드를 사용하여 행(row) 데이터를 설정하며, alias 속성이 설정된 경우 해당 alias속성을 기준으로 값을 설정합니다.

merge()#

다른 MetaView 객체의 데이터를 현재 객체에 병합하는 메서드입니다.

ts
declare function merge(
	target: MetaTable | MetaView, 
	option: number, 
	matchType?: boolean
): void;
  • target: 병합할 데이터를 포함한 원본 MetaTable 또는 MetaView 객체
  • option: 병합 방식을 지정하는 숫자형 옵션
    • 0: 로우(idx) 기준 병합, 초과 컬럼은 무시됩니다.
    • 1: 컬럼(key) 기준 병합, 초과 로우는 무시됩니다.
    • 2: 로우(idx) 기준 병합, 초과 컬럼은 채워집니다.
    • 3: 컬럼(key) 기준 병합, 초과 로우는 채워집니다.
  • matchType(선택): 행 유효성 검사 여부 (기본값 false)

merge() 메서드는 두 데이터 구조를 병합하며, 병합 방식과 유효성 검사 옵션을 조합하여 다양한 데이터를 처리할 수 있습니다.

  • 병합 방식은 옵션(option)을 통해 로우(idx) 또는 컬럼(key) 기준으로 동작합니다.
  • matchType을 활성화하면 컬럼 제약 조건을 확인 후 데이터 병합을 수행하며, 실패 시 예외를 발생시킵니다.
  • 데이터 병합 중 초과된 컬럼 또는 로우를 무시하거나 채우는 동작은 옵션 값에 따라 결정됩니다.

병합 옵션 0 - 로우 기준 병합, 초과 컬럼 무시#

컬럼 매칭 예제

js
const view1 = new MetaView('v1');
const view2 = new MetaView('v2');

// 데이터 행(row) 읽기 : read opt = 3
view1.read({ rows: [{ c1: 'R1', c2: 'R2' }] }, 3);
view2.read({ rows: [{ c1: 'R10', c2: 'R20' }] }, 3);

// 병합 opt = 0
view1.merge(view2, 0);

console.log(view1.columns.count); // Out: 2
console.log(view1.rows.count);    // Out: 2
console.log(view1.rows[0]['c1']); // Out: 'R1'
console.log(view1.rows[0]['c2']); // Out: 'R2'
console.log(view1.rows[1]['c1']); // Out: 'R10'
console.log(view1.rows[1]['c2']); // Out: 'R20'
  • option = 0으로 설정하면, 행(row) 기준으로 매칭되는 컬럼만 병합됩니다.

컬럼 일부 매칭 예제

js
const view1 = new MetaView('v1');
const view2 = new MetaView('v2');

// 데이터 행(row) 읽기 : read opt = 3
view1.read({ rows: [{ c1: 'R1', c2: 'R2' }] }, 3);
view2.read({ rows: [{ c1: 'R10', c3: 'R30' }] }, 3);

// 병합 opt = 0
view1.merge(view2, 0);

console.log(view1.columns.count); // Out: 2
console.log(view1.rows.count);    // Out: 2
console.log(view1.rows[0]['c1']); // Out: 'R1'
console.log(view1.rows[0]['c2']); // Out: 'R2'
console.log(view1.rows[1]['c1']); // Out: 'R10'
console.log(view1.rows[1]['c2']); // Out: ''
  • view2에서 매칭되지 않은 c2 컬럼은 빈 값('')으로 병합됩니다.

병합 옵션 1 - 컬럼 기준 병합, 초과 로우 무시#

컬럼 전부 비매칭 예제

js
const view1 = new MetaView('v1');
const view2 = new MetaView('v2');

// 데이터 행(row) 읽기 : read opt = 3
view1.read({ rows: [{ c1: 'R1', c2: 'R2' }] }, 3);
view2.read({ rows: [{ c3: 'R3', c4: 'R4' }, { c3: 'R30', c4: 'R40' }] }, 3);

// 병합 opt = 1
view1.merge(view2, 1);

console.log(view1.columns.count); // Out: 4
console.log(view1.rows.count);    // Out: 1
console.log(view1.rows[0]['c1']); // Out: 'R1'
console.log(view1.rows[0]['c2']); // Out: 'R2'
console.log(view1.rows[0]['c3']); // Out: 'R3'
console.log(view1.rows[0]['c4']); // Out: 'R4'
  • option = 1으로 설정하면, 컬럼 기준으로 매칭되어 병합되며, 컬럼 개수가 증가합니다.
  • 컬럼명이 중복되면, 예외가 발생합니다.
  • 대상의 행(row)이 원본보다 많으면 무시되고, 적으면 공백으로 채워집니다.

병합 옵션 2 - 로우 기준 병합, 초과 컬럼 채움#

컬럼 일부 매칭 예제

js
const view1 = new MetaView('view1');
const view2 = new MetaView('view2');

// 데이터 행(row) 읽기
view1.read({ rows: [{ c1: 'R1', c2: 'R2' }] }, 3);
view2.read({ rows: [{ c1: 'R10', c3: 'R30' }] }, 3);

// 병합 opt = 2
view1.merge(view2, 2);

console.log(view1.columns.count); // Out: 3
console.log(view1.rows.count);    // Out: 2
console.log(view1.rows[0]['c1']); // Out: 'R1'
console.log(view1.rows[0]['c2']); // Out: 'R2'
console.log(view1.rows[0]['c3']); // Out: ''
console.log(view1.rows[1]['c1']); // Out: 'R10'
console.log(view1.rows[1]['c2']); // Out: ''
console.log(view1.rows[1]['c3']); // Out: 'R30'
  • option = 2으로 설정하면, 행(row) 기준으로 매칭되는 컬럼만 병합됩니다.
  • 원본 view1에 채워진 c3 컬럼은 빈 값('')으로 채워집니다.
  • 대상 view2에 매칭되지 않은 c2 컬럼은 빈 값('')으로 채워집니다.

병합 옵션 3 - 컬럼 기준 병합, 초과 로우 채움#

컬럼 전부 비매칭 예제

js
const view1 = new MetaView('view1');
const view2 = new MetaView('view2');

// 데이터 행(row) 읽기
view1.read({ rows: [{ c1: 'R1', c2: 'R2' }] }, 3);
view2.read({ rows: [{ c3: 'R3', c4: 'R4' }, { c3: 'R30', c4: 'R40' }] }, 3);

// 병합 opt = 3
view1.merge(view2, 3);

console.log(view1.columns.count); // Out: 4
console.log(view1.rows.count);    // Out: 2
console.log(view1.rows[0]['c1']); // Out: 'R1'
console.log(view1.rows[0]['c2']); // Out: 'R2'
console.log(view1.rows[0]['c3']); // Out: 'R3'
console.log(view1.rows[0]['c4']); // Out: 'R4'
console.log(view1.rows[1]['c1']); // Out: ''
console.log(view1.rows[1]['c2']); // Out: ''
console.log(view1.rows[1]['c3']); // Out: 'R30'
console.log(view1.rows[1]['c4']); // Out: 'R40'
  • option = 3으로 설정하면, 컬럼 기준으로 매칭되어 병합되며, 컬럼 개수가 증가합니다.
  • 컬럼명이 중복되면, 예외가 발생합니다.
  • 대상의 행(row)이 원본보다 갯수가 크면 공백으로 채워지고, 작으면 예외가 발생합니다.

select()#

조건에 맞는 행(row)을 필터링하거나 특정 컬럼 데이터를 반환하는 메서드입니다.

ts
declare function select(
    filter: (row, idx, view) => boolean | string[] | arguments<string>, 
    colNames?: string[] | arguments<string>
): MetaRow[];
  • filter: 필터 콜백함수 또는 대상 컬럼명
    1. 함수: 행(row), 인덱스(idx), 원본 뷰(view)를 매개변수로 받아 boolean 타입을 반환합니다.
    2. string[]: 특정 컬럼명만 복사합니다.
    3. arguments<string>: 매개변수 형태로 전달된 컬럼명을 복사합니다.
  • colNames(선택): 복사 대상의 컬럼명 또는 컬럼 문자열 배열 또는 arguments<string> 형태
  • 반환값: 조건에 맞는 행 데이터(MetaRow[]) 배열.

select() 메서드는 MetaView 객체의 행 데이터를 조건에 따라 필터링하거나 특정 컬럼 데이터를 선택하여 배열 형태로 반환합니다.

  • 컬럼명을 배열 또는 인자로 전달하여 복사할 대상 컬럼을 지정할 수 있습니다.
  • filter 함수를 사용하여 조건에 만족하는 행(row)을 선택할 수 있습니다.
  • 선택된 데이터는 새로운 배열로 생성되므로, 원본 데이터와 독립적으로 사용할 수 있습니다.

필터 함수로 데이터 선택 예제

js
const view1 = new MetaView('v1');

// 데이터 행(row) 읽기
view1.read({ rows: [{ c1: 10, c2: 'R2' }, { c1: 20, c2: 'R20' }]}, 3);

// rows 선택
const rows = view1.select(row => row['c1'] > 10);

console.log(rows.length);   // Out: 1
console.log(rows[0]['c1']); // Out: 20
console.log(rows[0]['c2']); // Out: 'R20'
  • select() 메서드를 호출하여 c1 값이 10보다 큰 행만 선택합니다.
  • 선택된 행(row) 데이터는 배열로 반환합니다.

특정 컬럼 선택 예제

js
const view1 = new MetaView('V1');

// 데이터 행(row) 읽기
view1.read({ rows: [{ c1: 10, c2: 'R2' }, { c1: 20, c2: 'R20' }]}, 3);

// rows 선택
const rows = view1.select(['c1']);

console.log(rows.length);   // Out: 2
console.log(rows[0]['c1']); // Out: 10
console.log(rows[1]['c1']); // Out: 20
  • select() 메서드를 호출하여 c1 컬럼 데이터만 포함된 행(row) 배열을 반환합니다.

Tip: 필터함수와 대상컬럼을 조합하여 다양한 방식으로 데이터 조회에 활용할 수 있습니다.


output()#

현재 객체를 직렬화된 문자열로 내보내는 메서드입니다.

ts
declare function output(
	vOpt?: number, 
	stringify?: Function, 
	space?: string
): string;
  • vOpt(선택): 직렬화 옵션 (기본값 0)
    • 0: guid 참조 구조를 유지합니다 (_guid: 예, $ref: 예)
    • 1: guid 중복 구조로 출력합니다 (_guid: 예, $ref: 예)
    • 2: 비참조 구조로 출력합니다 (_guid: 아니오, $ref: 아니오).
  • stringify(선택): (선택) 사용자 정의 파서 출력 함수
  • space(선택): 출력 문자열의 들여쓰기 설정
  • 반환값: 직렬화된 데이터 문자열

output() 메서드는 MetaView 객체의 데이터를 JSON 문자열 또는 사용자 정의 형식으로 직렬화하여 반환합니다.

  • vOpt를 사용하여 참조 구조, 중복 구조, 비참조 구조를 선택적으로 설정할 수 있습니다.
  • stringify 함수는 데이터를 직렬화하는 데 사용되며, 사용자 정의 파서를 지정할 수 있습니다.
  • space 매개변수를 통해 직렬화된 출력의 가독성을 높이기 위해 들여쓰기 설정을 추가할 수 있습니다.

Tip: 반환된 데이터는 외부로 전달하거나 다른 MetaView 객체로 로드할 때 사용됩니다.

vOpt 에 대하여

  • opt = 0과 opt = 1은 동일하게 작동하지만, opt = 1은 MetaView의 참조 컬럼을 독립적인 객체로 직렬화합니다. 이 경우 객체에 참조값은 _guid값이 중복되어 구성됩니다.
  • opt = 2는 객체의 참조를 제거하여 독립적인 구조로 출력할 때 사용됩니다.
js
const view1 = new MetaView('v1');
const view2 = new MetaView('v2');

// 컬럼 추가
view1.columns.addValue('c1', 10);

// 문자열로 내보내기 : opt = 0
const data1 = view1.output(); 

// 문자열로 가져오기
view2.load(data1);

console.log(view1.viewName);            // Out: 'v1'
console.log(view1.columns['c1'].value); // Out: 10
console.log(view2.viewName);            // Out: 'v1'
console.log(view2.columns['c1'].value); // Out: 10
  • output() 메서드를 사용하여 view1 데이터를 JSON 문자열로 변환합니다.
  • view2 는 view1과 동일한 구조를 가집니다.

load()#

직렬화된 객체를 불러와서 컬럼과 행 데이터를 구성하는 메서드입니다.

ts
declare function load(
	data: object | string, 
	parse?: (data: string) => object
): void;
  • data: 로드할 데이터 객체 또는 JSON 문자열
    • 객체: getObject() 메서드를 통해 직렬화된 객체
    • 문자열: output() 메서드를 통해 직렬화된 객체의 JSON 문자열
  • parse(선택): (선택) JSON 문자열을 객체로 변환하는 사용자 정의 파서 함수
    • 함수가 제공되지 않으면 기본 JSON 파서를 사용합니다

load() 메서드는 직렬화된 객체 또는 JSON 문자열 데이터를 MetaView 객체에 로드하여 컬럼과 행 데이터를 구성합니다.

  • parse 함수를 사용하여 사용자 정의 방식으로 데이터를 처리할 수 있습니다.
  • load() 메서드를 실행하면, 기존 데이터는 초기화됩니다.
js
const view1 = new MetaView('v1');
const view2 = new MetaView('v2');
const view3 = new MetaView('v3');

// 컬럼 추가
view1.columns.addValue('c1', 10);

// 문자열로 내보내기
const data1 = view1.output();
// 객체로 내보내기
const data2 = view1.getObject();

// 문자열 불러오기
view2.load(data1);
// 객체 불러오기
view3.load(data2);

console.log(view1.viewName); // Out: 'v1'
console.log(view2.viewName); // Out: 'v1'
console.log(view3.viewName); // Out: 'v1'
console.log(view1.columns['c1'].value); // Out: 10
console.log(view2.columns['c1'].value); // Out: 10
console.log(view3.columns['c1'].value); // Out: 10
  • data1과 data2를 load() 메서드를 사용하여 view2와 view3에 로드합니다.
  • 모든 MetaView 객체는 동일한 컬럼과 데이터를 갖습니다.

write()#

현재 객체를 MetaView 스키마 타입의 객체로 변환하여 반환하는 메서드입니다.

ts
declare function write(vOpt?: number): object;
  • vOpt(선택) (number, 선택): 직렬화 옵션 (기본값 0)
    • 0: guid 참조 구조를 유지합니다 (_guid: 예, $ref: 예)
    • 1: guid 중복 구조로 출력합니다 (_guid: 예, $ref: 예)
    • 2: 비참조 구조로 출력합니다 (_guid: 아니오, $ref: 아니오)
  • 반환값: MetaView 스키마 타입 객체

write() 메서드는 컬럼(구조)과 행(데이터)을 MetaView 스키마 타입의 객체로 반환합니다.

Tip: 반환된 데이터는 외부 시스템으로 전달하거나 저장하는 데 활용됩니다.

MetaView 스키마 타입

ts
type ConstraintType = { 
	regex: RegExp,       // 검사할 정규식
	msg: string,         // 조건 미충족 시 출력할 메시지
	code?: string,       // 조건 미충족 시 반환할 코드 (선택적)
	condition?: boolean  // true: 매칭 조건, false: 비매칭 조건 (기본값: true)
};
type GuidType = { $ref: string } | string;
type EntitySchema = {
	_guid?: string,
	_baseEntity?: GuidType,
	columns?: {
		[key: string]: {
			_entity?: GuidType,
			_guid?: string,
			default?: number | string | boolean,
			caption?: string,
			required?: boolean,
			constraints?: ConstraintType[],
			getter?: () => any,
			setter?: (value: string | number | boolean) => void | any,
			$alias?: string,
			value?: string
		},
		$key?: string[]  // 컬럼의 순서
	},
	rows?: {
		[key: number]: {
			[key: string]: number | string | boolean;
		}
	}
};

rows 에 boolean 타입에 대한 이슈? #REVIEW

기본 참조 구조 직렬화 예제

js
const view = new MetaView('v1');
const c1 = new HTMLColumn('u_id', view, { default: 0, required: true });
const c2 = new HTMLColumn('name', view, { caption: 'Full Name' });

// 컬럼 추가
view.columns.add(c1);
view.columns.add(c2);

// 행 추가
view.rows.add(view.newRow());
view.rows[0]['u_id'] = 1;
view.rows[0]['name'] = 'Alice';
view.rows.add(view.newRow());
view.rows[1]['id'] = 2;
view.rows[1]['name'] = 'Bob';

// MetaView 스키마 쓰기 : opt = 2
const schema = view.write(2);
console.log(schema);
// Out: 
// {
//     "columns": {
//         "u_id": {
//             "default": 0,
//             "required": true
//         },
//         "name": {
//             "caption": "Full Name"
//         },
//         "$key": ["u_id", "name"]
//     },
//     "rows": [
//         { "u_id": 1, "name": "Alice" },
//         { "u_id": 2, "name": "Bob" }
//     ]
// }
  • write(2): 컬럼과 행 데이터를 비참조 구조로 직렬화하여 반환합니다.

writeSchema()#

 현재 객체의 컬럼(구조) 정보를 MetaView 스키마 타입의 객체로 변환하여 반환하는 메서드입니다.

ts
declare function writeSchema(vOpt?: number): object;
  • vOpt(선택): (선택) 직렬화 옵션 (기본값 0)
    • 0: guid 참조 구조를 유지합니다 (_guid: 예, $ref: 예)
    • 1: guid 중복 구조로 출력합니다 (_guid: 예, $ref: 예)
    • 2: 비참조 구조로 출력합니다 (_guid: 아니오, $ref: 아니오)
  • 반환값: MetaView 스키마 타입 객체

writeSchema() 메서드는 MetaView 객체의 컬럼 정의를 추출하여 스키마 형태로 반환합니다.

  • 반환된 객체는 컬럼 이름, 기본값, 캡션, 필수 여부 등 컬럼의 메타데이터를 포함합니다.

Tip: 데이터를 제외한 구조 정보를 관리하거나 저장할 때 유용합니다.

구조 스키마 타입

ts
type ConstraintType = { 
	regex: RegExp,       // 검사할 정규식
	msg: string,         // 조건 미충족 시 출력할 메시지
	code?: string,       // 조건 미충족 시 반환할 코드 (선택적)
	condition?: boolean  // true: 매칭 조건, false: 비매칭 조건 (기본값: true)
};
type GuidType = { $ref: string } | string;
type EntitySchema = {
	_guid?: string,
	_baseEntity?: GuidType,
	columns?: {
		[key: string]: {
			_entity?: GuidType,
			_guid?: string,
			default?: number | string | boolean,
			caption?: string,
			required?: boolean,
			constraints?: ConstraintType[],
			getter?: () => any,
			setter?: (value: string | number | boolean) => void | any,
			$alias?: string,
			value?: string
		},
		$key?: string[]  // 컬럼의 순서
	}
};

MetaView 컬럼 구조 쓰기 예제

js
const view = new MetaView('v1');
const c1 = new HTMLColumn('u_id', view, { default: 0, required: true });
const c2 = new HTMLColumn('name', view, { caption: 'Full Name' });

// 컬럼 추가
view.columns.add(c1);
view.columns.add(c2);

// 행 추가
view.rows.add(view.newRow());
view.rows[0]['u_id'] = 1;
view.rows[0]['name'] = 'Alice';

// 스키마 쓰기
const schema = view.writeSchema(2);

console.log(schema);
// Out: 
// {
//     "columns": {
//         "u_id": {
//             "default": 0,
//             "required": true
//         },
//         "name": {
//             "caption": "Full Name"
//         },
//         "$key": ["u_id", "name"]
//     },
// }
  • writeSchema() 메서드를 호출하여 컬럼 정의를 직렬화된 스키마 객체로 반환합니다.
  • 반환된 객체는 컬럼 이름과 메타데이터를 포함하며, 컬럼 순서 정보($key)를 제공합니다.

writeData()#

현재 객체의 행(row)을 스키마 타입의 객체로 변환하여 반환하는 메서드입니다.

ts
declare function writeData(vOpt?: number) : object;
  • vOpt(선택): 직렬화 옵션 (기본값 0)
    • 0: guid 참조 구조를 유지합니다 (_guid: 예, $ref: 예)
    • 1: guid 중복 구조로 출력합니다 (_guid: 예, $ref: 예)
    • 2: 비참조 구조로 출력합니다 (_guid: 아니오, $ref: 아니오).
  • 반환값: MetaView 스키마 타입 객체

writeData() 메서드는 MetaView 객체의 행(데이터)를 추출하여 스키마 형태로 반환합니다.

  • 컬럼 구조를 제외한 데이터를 관리하거나 저장할 때 유용합니다.

Tip: readSchema() 메서드에서 옵션을 지정하여 행(row)을 기준으로 컬럼을 가져올 수 있습니다.

데이터 스키마 타입

ts
type DataSchema = {
	rows?: {
		[key: number]: {
			[key: string]: number | string | boolean;
		}
	}
};

MetaView 행(row) 쓰기 예제

js
const view = new MetaView('v1');

// 컬럼 추가
view.columns.add('u_id');
view.columns.add('name');

view.rows.add({ u_id: 1, name: 'Alice' });
view.rows.add({ u_id: 2, name: 'Bob' });

// 데이터 쓰기 : opt = 2
const data = view.writeData(2);

console.log(data);
// Out:
// {
//     "rows": [
//         { "u_id": 1, "name": "Alice" },
//         { "u_id": 2, "name": "Bob" }
//     ]
// }
  • writeData() 메서드를 호출하여 행 데이터를 직렬화된 객체 배열로 반환합니다.

read()#

MetaView 스키마 타입 객체를 읽어오는 메서드입니다.

ts
declare function read(source: object | MetaView | string, option?: number): void;
  • source: 읽어올 데이터 소스
    • 객체: 스키마 또는 데이터 구조
    • MetaView: 기존 MetaView 객체
    • 문자열: JSON 형식의 직렬화된 데이터
  • option(선택): 읽기 동작 옵션 (기본값 3)
    • 1: 컬럼(구조)만 읽기
    • 2: 로우(데이터)만 읽기
    • 3: 컬럼과 로우 모두 읽기

read() 메서드는 MetaView 객체 또는 직렬화 객체 또는 스키마 객체를 읽어와 MetaView 객체를 구성합니다.

  • 기존에 설정된 정보는 유지되며, 병합과 유사한 역활을 합니다.
  • option 값에 따라 컬럼(columns)과 로우(rows) 데이터를 선택적으로 읽어올 수 있습니다.

Tip: getObject() 메서드로 MetaView 의 직렬화 객체를 얻을 수 있으며, wrtie() 메서드로 MetaView 의 스키마 객체를 얻을 수 있습니다.

MetaView 스키마 타입

ts
type ConstraintType = { 
	regex: RegExp,       // 검사할 정규식
	msg: string,         // 조건 미충족 시 출력할 메시지
	code?: string,       // 조건 미충족 시 반환할 코드 (선택적)
	condition?: boolean  // true: 매칭 조건, false: 비매칭 조건 (기본값: true)
};
type GuidType = { $ref: string } | string;
type EntitySchema = {
	_guid?: string,
	_baseEntity?: GuidType,
	columns?: {
		[key: string]: {
			_entity?: GuidType,
			_guid?: string,
			default?: number | string | boolean,
			caption?: string,
			required?: boolean,
			constraints?: ConstraintType[],
			getter?: () => any,
			setter?: (value: string | number | boolean) => void | any,
			$alias?: string,
			value?: string
		},
		$key?: string[]  // 컬럼의 순서
	},
	rows?: {
		[key: number]: {
			[key: string]: number | string | boolean;
		}
	}
};

MetaView 객체에서 읽기 예제

js
const view1 = new MetaView('v1');
const view2 = new MetaView('v2', view1); // 전체 참조 뷰
const view3 = new MetaView('v3');

// 컬럼 추가
view1.columns.add('c1');
view2.columns.add('c2');
view3.columns.add('c3', view2.columns); // 컬럼 일부 참조

// 스키마를 읽을 뷰 생성
const v1 = new MetaView('view1');
const v2 = new MetaView('view2');
const v3 = new MetaView('view3');

// 컬럼 및 데이터 읽기 : opt = 3
v1.read(view1);
v2.read(view2);
v3.read(view3);

console.log(v1.columns.count); // Out: 3
console.log(v2.columns.count); // Out: 2
console.log(v3.columns.count); // Out: 1
  • MetaView 객체에서 컬럼과 행 데이터를 읽어옵니다.

스키마 객체 읽기 예제

js
const view = new MetaView('v1');
const schema = {
	columns: { c1: 'D1', c2: 'D2'},
    rows: [{ c1: 'R1', c2: 'R2' }]
};

// 컬럼 및 데이터 읽기 : opt = 3
view.read(schema);

console.log(view.columns.count); // Out: 2
console.log(view.rows.count);    // Out: 1
  • 스키마 타입의 컬럼과 행 데이터를 읽어옵니다.

readSchema()#

MetaView 스키마 타입 객체의 컬럼(구조) 정보를 읽어오는 메서드입니다.

ts
declare function readSchema(schema: object, isReadRow?: boolean): void;
  • schema: 읽어올 스키마 객체
  • isReadRow(선택): 로우 키를 읽어서 컬럼 등록 여부 (기본값 false)
    • true이면 row[0]을 기준으로 컬럼을 추가합니다.

readSchema() 메서드는 MetaView 스키마 타입 객체에서 컬럼 정보를 읽어오는 메서드입니다.

  • isReadRow = true 인자를 설정하면, 첫번째 행(row)정보를 사용하여 기본 컬럼을 구성합니다.

컬럼 스키마 타입

ts
type ConstraintType = { 
	regex: RegExp,       // 검사할 정규식
	msg: string,         // 조건 미충족 시 출력할 메시지
	code?: string,       // 조건 미충족 시 반환할 코드 (선택적)
	condition?: boolean  // true: 매칭 조건, false: 비매칭 조건 (기본값: true)
};
type GuidType = { $ref: string } | string;
type EntitySchema = {
	_guid?: string,
	_baseEntity?: GuidType,
	columns?: {
		[key: string]: {
			_entity?: GuidType,
			_guid?: string,
			default?: number | string | boolean,
			caption?: string,
			required?: boolean,
			constraints?: ConstraintType[],
			getter?: () => any,
			setter?: (value: string | number | boolean) => void | any,
			$alias?: string,
			value?: string
		},
		$key?: string[]  // 컬럼의 순서
	}
};

컬럼 정보 읽기 예제

js
const view = new MetaView('v1');
const schema = {
    columns: { c1: 'D1', c2: 'D2' }
};

// 컬럼 읽기
view.readSchema(schema);

console.log(view.columns.count);       // Out: 2
console.log(view.columns['c1'].value); // Out: 'D1'
console.log(view.columns['c2'].value); // Out: 'D2'
  • 스키마 타입의 컬럼을 읽어옵니다.

읽기 순서 변경 예제

js
const view = new MetaView('t1');
const schema = {
    columns: {
        $key: ['c2', 'c1'],  // 키 위치 변경
        c1: { caption: 'Column1' }, 
        c2: { caption: 'Column2' }
    }
};

view.readSchema(schema);

console.log(view.columns.count);  // Out: 2
console.log(view.columns['c1'].caption); // Out: 'Column1'
console.log(view.columns['c2'].caption); // Out: 'Column2'
console.log(view.columns[0].caption); // Out: 'Column2'
console.log(view.columns[1].caption); // Out: 'Column1'
  • $key 속성을 사용하여 컬럼의 순서를 조정할 수 있습니다.

readData()#

MetaView 스키마 타입 객체의 행(데이터) 정보를 읽어오는 메서드입니다.

ts
declare function readData(data: object): void;
  • data: 읽어올 데이터 객체

readData()메서드는 데이터 객체에서 rows 속성에 존재하는 컬럼의 행(row) 데이터만 읽습니다.

  • 행(row)의 키는 컬럼명과 같으며, alias 속성이 설정되어 있으면 우선합니다.

행 스키마 타입

ts
type DataSchema = {
	rows?: {
		[key: number]: {
			[key: string]: number | string | boolean;
		}
	}
};

행 데이터 읽기 예제

js
const view = new MetaView('T1');
const data = {
    rows: [{ c1: 'R1', c2: 'R2' }, { c1: 'R3', c2: 'R4' }]
};

// 컬럼 추가
view.columns.add('c1');
view.columns.add('c2');

// 행(row) 데이터 읽기
view.readData(data);

console.log(view.rows.count); // Out: 2
console.log(view.rows[0]['c1']); // Out: 'R1'
console.log(view.rows[0]['c2']); // Out: 'R2'
console.log(view.rows[1]['c1']); // Out: 'R3'
console.log(view.rows[1]['c2']); // Out: 'R4'
  • readData() 메서드를 사용하여 data 객체의 행 읽어옵니다.

컬럼없는 데이터 읽기 예제

js
const view = new MetaView('T1');
const data = {
    rows: [{ c1: 'R1', c2: 'R2' }, { c1: 'R3', c2: 'R4' }]
};

view.readData(data);

console.log(view.rows.count); // Out: 0
  • readData() 메서드는 컬럼이 없는 경우 데이터를 로드하지 않습니다.

검색어를 입력해 보세요.