이 문서에서는 도서 관리 시스템을 개발하는 방법을 설명합니다. 이 시스템은 관계형 데이터베이스(RelationalStore)를 활용하여 도서의 조회, 수정, 삭제 및 추가 기능을 제공합니다.

프로젝트 소개

도서 관리 시스템은 다음과 같은 주요 기능을 포함합니다:

• 도서 조회: 사용자는 시스템에 저장된 모든 도서 정보(제목, 저자, 출판 연도 등)를 볼 수 있습니다.
• 도서 수정: 사용자는 도서 정보를 수정할 수 있습니다(예: 제목, 저자, 출판 연도 변경).
• 도서 삭제: 사용자는 특정 도서 레코드를 시스템에서 삭제할 수 있습니다.
• 도서 추가: 사용자는 새로운 도서 정보를 시스템에 추가할 수 있습니다.

프로젝트 구조

<!-- common/constants/CommonConstants.ets -->
import relationalStore from '@ohos.data.relationalStore';
import Book from '../../model/Book';

export default class CommonConstants {
  static readonly STORE_CONFIG = {
    name: 'library.db',
    securityLevel: relationalStore.SecurityLevel.S1
  };

  static readonly BOOKS_TABLE = {
    tableName: 'books',
    sqlCreate: 'CREATE TABLE IF NOT EXISTS books (id INTEGER PRIMARY KEY AUTOINCREMENT, title TEXT, author TEXT, publicationYear TEXT, genre TEXT)'
  };
}

<!-- model/Book.ets -->
export default interface Book {
  id: number;
  title: string;
  author: string;
  publicationYear: string;
  genre: string;
}

UI 레이아웃 예시

// pages/Index.ets
import router from '@ohos.router';

@Entry
@Component
struct Index {
  build() {
    Column({ space: 10 }) {
      Text("도서 관리 시스템")
        .fontSize(50)
        .margin({ bottom: 30 });

      Button('도서 조회')
        .fontSize(20)
        .width("70%")
        .height("7%")
        .onClick(() => {
          router.pushUrl({ url: 'pages/BooksListPage', params: { state: 1 } });
        });

      Button('도서 추가')
        .fontSize(20)
        .width("70%")
        .height("7%")
        .onClick(() => {
          router.pushUrl({ url: 'pages/AddBookPage' });
        });

      Button('도서 삭제')
        .fontSize(20)
        .width("70%")
        .height("7%")
        .onClick(() => {
          router.pushUrl({ url: 'pages/BooksListPage', params: { state: 3 } });
        });

      Button('도서 수정')
        .fontSize(20)
        .width("70%")
        .height("7%")
        .onClick(() => {
          router.pushUrl({ url: 'pages/BooksListPage', params: { state: 2 } });
        });
    }
    .alignItems(HorizontalAlign.Center)
    .justifyContent(FlexAlign.Center)
    .width('100%')
    .height('100%');
  }
}

Rdb 클래스 설계

// common/database/Rdb.ets
import relationalStore from '@ohos.data.relationalStore';
import CommonConstants from '../constants/CommonConstants';

export default class Rdb {
  private dbInstance: relationalStore.RdbStore | null = null;

  constructor(callback: Function) {
    let context = getContext(this) as Context;
    relationalStore.getRdbStore(context, CommonConstants.STORE_CONFIG, (err, rdb) => {
      if (err) {
        callback(false);
        return;
      }
      this.dbInstance = rdb;
      this.createTable(CommonConstants.BOOKS_TABLE.sqlCreate, callback);
    });
  }

  createTable(sqlCreateTable: string, callback: Function) {
    if (!this.dbInstance || !sqlCreateTable) {
      callback(false);
      return;
    }
    this.dbInstance.executeSql(sqlCreateTable)
      .then(() => callback(true))
      .catch(() => callback(false));
  }

  insertData(data: relationalStore.ValuesBucket, tableName: string, callback: Function) {
    if (this.dbInstance) {
      this.dbInstance.insert(tableName, data, (err, ret) => {
        if (err) {
          callback(false);
          return;
        }
        callback(ret);
      });
    }
  }

  deleteData(predicates: relationalStore.RdbPredicates, callback: Function) {
    if (this.dbInstance) {
      this.dbInstance.delete(predicates, (err, ret) => {
        if (err) {
          callback(false);
          return;
        }
        callback(ret);
      });
    }
  }

  updateData(predicates: relationalStore.RdbPredicates, data: relationalStore.ValuesBucket, callback: Function) {
    if (this.dbInstance) {
      this.dbInstance.update(data, predicates, (err, ret) => {
        if (err) {
          callback(false);
          return;
        }
        callback(ret);
      });
    }
  }

  query(predicates: relationalStore.RdbPredicates, callback: Function) {
    if (this.dbInstance) {
      this.dbInstance.query(predicates).then((resultSet) => {
        callback(resultSet);
        resultSet.close();
      }).catch(() => callback(false));
    }
  }
}

BooksTable 클래스 설계

// common/database/tables/BooksTable.ets
import relationalStore from '@ohos.data.relationalStore';
import Book from '../../../model/Book';
import CommonConstants from '../../constants/CommonConstants';
import Rdb from '../Rdb';

export default class BooksTable {
  public static instance: BooksTable = null;
  private dbOps: Rdb;
  private tableName: string = CommonConstants.BOOKS_TABLE.tableName;
  private sqlCreateTable: string = CommonConstants.BOOKS_TABLE.sqlCreate;

  constructor(callback: Function) {
    this.dbOps = new Rdb((flag) => callback(flag));
  }

  insertData(book: Book, callback: Function) {
    const valueBucket: relationalStore.ValuesBucket = {};
    valueBucket.title = book.title;
    valueBucket.author = book.author;
    valueBucket.publicationYear = book.publicationYear;
    valueBucket.genre = book.genre;
    this.dbOps.insertData(valueBucket, this.tableName, callback);
  }

  updateData(book: Book, callback: Function) {
    const valueBucket: relationalStore.ValuesBucket = {};
    valueBucket.title = book.title;
    valueBucket.author = book.author;
    valueBucket.publicationYear = book.publicationYear;
    valueBucket.genre = book.genre;

    let predicates = new relationalStore.RdbPredicates(this.tableName);
    predicates.equalTo('id', book.id);

    this.dbOps.updateData(predicates, valueBucket, callback);
  }

  deleteById(id: number, callback: Function) {
    let predicates = new relationalStore.RdbPredicates(this.tableName);
    predicates.equalTo('id', id);
    this.dbOps.deleteData(predicates, callback);
  }

  query(id: number, callback: Function, isAll: boolean = true) {
    let predicates = new relationalStore.RdbPredicates(this.tableName);
    if (!isAll) {
      predicates.equalTo('id', id);
    }

    this.dbOps.query(predicates, (resultSet) => {
      let count = resultSet.rowCount;
      if (count === 0 || typeof count === 'string') {
        console.log('Query no results!');
        callback([]);
      } else {
        resultSet.goToFirstRow();
        const result: Book[] = [];
        for (let i = 0; i < count; i++) {
          let tmp: Book = {
            id: 0, title: '', author: '', publicationYear: '', genre: ''
          };
          tmp.id = resultSet.getDouble(resultSet.getColumnIndex('id'));
          tmp.title = resultSet.getString(resultSet.getColumnIndex('title'));
          tmp.author = resultSet.getString(resultSet.getColumnIndex('author'));
          tmp.publicationYear = resultSet.getString(resultSet.getColumnIndex('publicationYear'));
          tmp.genre = resultSet.getString(resultSet.getColumnIndex('genre'));
          result[i] = tmp;
          resultSet.goToNextRow();
        }
        callback(result);
      }
    });
  }

  queryById(id: number, callback: Function) {
    this.query(id, callback, false);
  }

  queryAll(callback: Function) {
    this.query(null, callback, true);
  }
}