def get_account_id(self, connection, data):
""" 유저 account_id 조회
Args:
connection : 데이터베이스 연결 객체
data : 서비스에서 넘겨 받은 dict 객체
Author: 김민구
Returns:
1 (account_id)
Raises:
500, {'message': 'database_error', 'error_message': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
History:
2021-01-05(김민구): 초기 생성
"""
sql = """
SELECT
account_id
FROM
users
WHERE
email = %(email)s
"""
try:
with connection.cursor() as cursor:
cursor.execute(sql, data)
return cursor.fetchone()[0]
except Exception:
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def get_enquiry_reply_list(self, connection, data):
""" 답변 리스트를 조회
Args:
connection: 데이터베이스 연결 객체
data: 서비스에서 넘겨 받은 dict
enquiry_ids = 질문 아이디들이 담긴 튜플
Returns: 답변이 담긴 리스트 반환
[
{
"account_id": 2,
"content": "답변드릴게요",
"created_at": "2021-01-04 12:38:12",
"enquiry_id": 102,
"id": 52,
"seller_name": "나는셀러2"
}
]
Raises:
500, {'message': 'database_error', 'error_message': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
400, {'message': 'key_error', 'error_message': format(e)} : 잘못 입력된 키값
History:
2021-01-04(김민구): 초기 생성
"""
sql = """
SELECT
enquiry_reply.id
, enquiry_reply.content
, enquiry_reply.account_id
, seller.`name` AS seller_name
, enquiry_reply.created_at
, enquiry_reply.enquiry_id
FROM
enquiry_replies AS enquiry_reply
INNER JOIN sellers AS seller
ON seller.account_id = enquiry_reply.account_id
WHERE
enquiry_reply.is_deleted = 0
AND enquiry_reply.enquiry_id IN %(enquiry_ids)s
"""
try:
with connection.cursor(pymysql.cursors.DictCursor) as cursor:
cursor.execute(sql, data)
result = {row['enquiry_id']: row for row in cursor.fetchall()}
return result
except Exception:
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def get_user_information(self, connection, data):
""" 유저 account_id, 로그인아이디, 비밀번호, permission_type 조회
Args:
connection : 데이터베이스 연결 객체
data : 서비스에서 넘겨 받은 dict 객체
Author: 김민구
Returns:
{'account_id': 1, 'username': '******', 'password': '******', permission_type_id: 3}
Raises:
500, {'message': 'database_error', 'error_message': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
History:
2020-12-29(김민구): 초기 생성
2020-12-31(김민구): 에러 문구 변경
"""
sql = """
SELECT
id
, username
, password
, permission_type_id
FROM
accounts
WHERE
is_deleted=0
"""
try:
if 'account_id' in data:
sql += """
AND id = %(account_id)s
"""
elif 'username' in data:
sql += """
AND username = %(username)s
"""
with connection.cursor(pymysql.cursors.DictCursor) as cursor:
cursor.execute(sql, data)
return cursor.fetchone()
except Exception:
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def get_product_size_dao(self, connection, data):
""" 상품 사이즈를 조회한다.
상품이 여러 사이즈들을 가질 수 있게 되고
사이즈도 여러 상품들을 가질 수 있게 됨으로
중복이 발생한다. 그래서 DISTINCT 를 사용
Args:
connection : 데이터베이스 연결 객체
data : 서비스에서 넘겨 받은 data
Author: 김기용
Returns:
{
size_id: 1,
size_name: black
}
Raises:
500, {'message': 'database_error', 'error_message': '서버에 알 수 없는 에러가 발생했습니다.'}
History:
2020-01-00(김기용): 초기 생성
"""
sql = """
SELECT DISTINCT
size.id AS size_id
,size.name AS size_name
FROM
stocks
INNER JOIN sizes as size
ON stocks.size_id = size.id
WHERE product_id = %(product_id)s
;
"""
try:
with connection.cursor(pymysql.cursors.DictCursor) as cursor:
cursor.execute(sql, data)
sizes = cursor.fetchall()
return sizes
except Exception:
traceback.print_exc()
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def get_product_color_dao(self, connection, data):
""" 상품 컬러들을 조회한다.
상품이 여러 컬러들을 가질 수 있게 되고
컬러도 여러 상품들을 가질 수 있게 됨으로
중복이 발생한다. 그래서 DISTINCT를 사용
Args:
connection : 데이터베이스 연결 객체
data : 서비스에서 넘겨 받은 data
Author: 김기용
Returns:
{
color_id: 1,
color_name: black
}
Raises:
500, {'message': 'database_error', 'error_message': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
History:
2020-01-00(김기용): 초기 생성
"""
sql = """
SELECT DISTINCT
color.name AS color_name
, color.id AS color_id
FROM
stocks
INNER JOIN colors as color
ON stocks.color_id = color.id
WHERE product_id = %(product_id)s
;
"""
try:
with connection.cursor(pymysql.cursors.DictCursor) as cursor:
cursor.execute(sql, data)
color = cursor.fetchall()
return color
except Exception:
traceback.print_exc()
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def get_event(self, connection, data):
""" 상품 리스트 조회
Args:
connection : 데이터베이스 연결 객체
data : 서비스에서 넘겨 받은 dict
Author: 김민구
Returns:
{
event_id: 1,
event_banner_image: 'url'
}
Raises:
500, {'message': 'database_error', 'error_message': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
History:
2020-12-30(김민구): 초기 생성
2020-12-31(김민구): 에러 문구 변경 / 1개의 이벤트 배너 반환하는 작업으로 수정
"""
sql = """
SELECT
id AS event_id
, banner_image AS event_banner_image
FROM
events
WHERE
end_date > now()
AND is_display = 1
AND is_deleted = 0
ORDER BY
id ASC
LIMIT %(offset)s, 1
"""
try:
with connection.cursor(pymysql.cursors.DictCursor) as cursor:
cursor.execute(sql, data)
result = cursor.fetchone()
return result
except Exception:
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def create_user(self, connection, data):
""" 유저 생성
Args:
connection : 데이터베이스 연결 객체
data : 서비스에서 넘겨 받은 dict 객체
Author: 김민구
Returns:
0 : 유저 생성 실패
1 : 유저 생성 성공
Raises:
500, {'message': 'database_error', 'error_message': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
500, {'message': 'data_manipulation_fail', 'error_message': '유저 등록을 실패하였습니다.'} : 데이터 조작 에러
History:
2020-12-28(김민구): 초기 생성
2020-12-31(김민구): 에러 문구 변경
2021-01-02(김민구): 데이터 조작 에러 추가
"""
sql = """
INSERT INTO users (
account_id
, phone
, email
) VALUES (
%(account_id)s
, %(phone)s
, %(email)s
);
"""
try:
with connection.cursor() as cursor:
result = cursor.execute(sql, data)
if not result:
raise DataManipulationFail('유저 등록을 실패하였습니다.')
except DataManipulationFail as e:
raise e
except Exception:
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def create_account(self, connection, data):
""" account 생성
Args:
connection : 데이터베이스 연결 객체
data : 서비스에서 넘겨 받은 dict 객체
Author: 김민구
Returns:
account_id : account 생성 후 아이디 반환
Raises:
500, {'message': 'database_error', 'error_message': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러,
500, {'message': 'data_manipulation_fail', 'error_message': '유저 등록을 실패하였습니다.'} : 데이터 조작 에러
History:
2020-12-28(김민구): 초기 생성
2020-12-31(김민구): 에러 문구 변경
2021-01-02(김민구): 데이터 조작 에러 추가
"""
sql = """
INSERT INTO accounts (
username
, password
, permission_type_id
) VALUES (
%(username)s
, %(password)s
, %(permission_type_id)s
);
"""
try:
with connection.cursor() as cursor:
result = cursor.execute(sql, data)
if not result:
raise DataManipulationFail('유저 등록을 실패하였습니다.')
return cursor.lastrowid
except DataManipulationFail as e:
raise e
except Exception:
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def get_second_category_list(self, connection):
""" main 카테고리 리스트 조회
Args:
connection : 데이터베이스 연결 객체
Author: 김민구
Returns:
result (main_categories)
[
{
'id' : 1,
'name' : '상의',
'menu_id' : 6
}
]
Raises:
500, {'message': 'database_error', 'errorMessage': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
History:
2020-12-30(김민구): 초기 생성
2020-12-31(김민구): 에러 문구 변경
"""
sql = """
SELECT
id
, `name`
, menu_id
FROM
main_categories
WHERE
is_deleted = 0;
"""
try:
with connection.cursor(pymysql.cursors.DictCursor) as cursor:
cursor.execute(sql)
result = cursor.fetchall()
return result
except Exception:
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def update_bookmark_volume_count(self, connection, data):
""" 상품 북마크 수 업데이트
Args:
connection : 데이터베이스 연결 객체
data : 서비스에서 넘겨 받은 dict ( product_id, account_id, count )
Returns:
None
Raises:
500, {'message': 'database_error', 'errorMessage': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
500, {'message': 'data_manipulation_fail', 'error_message': '북마크 추가 혹은 삭제를 실패하였습니다.'} : 데이터 조작 에러
History:
2021-01-02(김민구): 초기 생성
Notes:
bookmark_count는 unsigned가 걸려있음
만약 0인 상태에서 -1이 연산된다면 데이터 입력이 실패하게 된다.
이 때 에러를 발생시키지 않고 success로 넘긴다.
데이터베이스의 unsigned error 번호는 1690이므로 1690에 대한 에러가 뜬다면 None을 리턴시킨다.
"""
sql = """
UPDATE
bookmark_volumes
SET
bookmark_count = bookmark_count + %(count)s
WHERE
product_id = %(product_id)s
"""
try:
with connection.cursor() as cursor:
cursor.execute(sql, data)
except Exception as e:
if '1690' in e.__str__():
return None
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def get_product_image_dao(self, connection, data):
""" 상품 이미지들을 조회한다.
Args:
connection : 데이터베이스 연결 객체
offset : 서비스에서 넘겨 받은 int
Author: 김기용
Returns:
{
image_id: 1,
images_url: www.example.com
}
Raises:
500, {'message': 'database_error', 'error_message': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
History:
2020-01-00(김기용): 초기 생성
"""
sql = """
SELECT DISTINCT
product_image.id AS image_id
, product_image.image_url AS image_url
FROM
product_images AS product_image
WHERE
product_id = %(product_id)s
"""
try:
with connection.cursor(pymysql.cursors.DictCursor) as cursor:
cursor.execute(sql, data)
images = cursor.fetchall()
return images
except Exception:
traceback.print_exc()
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def get_bookmark_exist(self, connection, data):
""" 해당 유저가 상품을 북마크 했는지 확인
Args:
connection : 데이터베이스 연결 객체
data : 서비스에서 넘겨 받은 dict ( product_id, account_id )
Returns: 북마크 존재 유무를 반환
1 : 해당 북마크가 존재
0 : 해당 북마크가 존재하지 않음
Raises:
500, {'message': 'database_error', 'errorMessage': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
History:
2021-01-02(김민구): 초기 생성
"""
sql = """
SELECT
EXISTS
(
SELECT
id
FROM
bookmarks
WHERE
account_id = %(account_id)s
AND product_id = %(product_id)s
AND is_deleted = 0
);
"""
try:
with connection.cursor() as cursor:
cursor.execute(sql, data)
result = cursor.fetchone()[0]
return result
except Exception:
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def create_bookmark(self, connection, data):
""" 상품 북마크 추가
Args:
connection : 데이터베이스 연결 객체
data : 서비스에서 넘겨 받은 dict ( product_id, account_id )
Returns:
None
Raises:
500, {'message': 'database_error', 'errorMessage': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
500, {'message': 'data_manipulation_fail', 'error_message': '북마크 추가를 실패하였습니다.'} : 데이터 조작 에러
History:
2021-01-02(김민구): 초기 생성
"""
sql = """
INSERT INTO bookmarks (
account_id,
product_id
) VALUES (
%(account_id)s,
%(product_id)s
);
"""
try:
with connection.cursor() as cursor:
result = cursor.execute(sql, data)
if not result:
raise DataManipulationFail('북마크 추가를 실패하였습니다.')
except DataManipulationFail as e:
raise e
except Exception:
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def get_enquiry_type_list(self, connection):
""" 질문 유형 리스트를 조회
Args:
connection: 데이터베이스 연결 객체
Returns: 질문 유형이 담긴 리스트 반환
[
{
"id": 1,
"name": "상품 문의"
}
]
Raises:
500, {'message': 'database_error', 'error_message': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
History:
2021-01-04(김민구): 초기 생성
"""
sql = """
SELECT
id,
name
FROM
enquiry_types
WHERE
is_deleted = 0;
"""
try:
with connection.cursor(pymysql.cursors.DictCursor) as cursor:
cursor.execute(sql)
result = cursor.fetchall()
return result
except Exception:
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def delete_bookmark(self, connection, data):
""" 상품 북마크 삭제
Args:
connection : 데이터베이스 연결 객체
data : 서비스에서 넘겨 받은 dict ( product_id, account_id )
Returns:
None
Raises:
500, {'message': 'database_error', 'errorMessage': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
500, {'message': 'data_manipulation_fail', 'error_message': '북마크 삭제를 실패하였습니다.'} : 데이터 조작 에러
History:
2021-01-02(김민구): 초기 생성
"""
sql = """
UPDATE
bookmarks
SET
is_deleted = 1
WHERE
account_id = %(account_id)s
AND product_id = %(product_id)s
"""
try:
with connection.cursor() as cursor:
result = cursor.execute(sql, data)
if not result:
raise DataManipulationFail('북마크 삭제를 실패하였습니다.')
except DataManipulationFail as e:
raise e
except Exception:
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def email_exist_check(self, connection, data):
""" 유저 이메일 중복 검사
Args:
connection : 데이터베이스 연결 객체
data : 서비스에서 넘겨 받은 dict 객체
Author: 김민구
Returns:
0 : 해당 유저 없음
1 : 해당 유저 존재
Raises:
500, {'message': 'database_error', 'error_message': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
History:
2020-12-28(김민구): 초기 생성
2020-12-31(김민구): 에러 문구 변경
"""
sql = """
SELECT
EXISTS
(SELECT account_id FROM users WHERE email = %(email)s)
AS user_exist;
"""
try:
with connection.cursor() as cursor:
cursor.execute(sql, data)
result = cursor.fetchone()[0]
return result
except Exception:
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def get_product_list(self, connection, data):
""" 상품 리스트 조회
Args:
connection : 데이터베이스 연결 객체
data : 서비스에서 넘겨 받은 dict
Author: 김민구
Returns: 30개의 상품정보
[
{
'image': 'url',
'seller_id': 1,
'seller_name': '둘리',
'product_id': 1,
'product_name': '성보의 하루',
'origin_price': 10000.0,
'discount_rate': 0.1,
'discounted_price': 9000.0,
'sales_count': 30
},
]
Raises:
500, {'message': 'database_error', 'error_message': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
History:
2020-12-30(김민구): 초기 생성
2020-12-31(김민구): 에러 문구 변경 / 이벤트에 대한 상품을 반환하는 작업으로 수정
"""
sql = """
SELECT
product_image.image_url
, product.seller_id AS seller_id
, seller.`name` AS seller_name
, product.id AS product_id
, product.`name` AS product_name
, product.origin_price
, product.discount_rate
, product.discounted_price
, product_sales_volume.sales_count
FROM
events_products AS event_product
INNER JOIN products AS product
ON event_product.product_id = product.id
INNER JOIN product_images AS product_image
ON product_image.product_id = product.id
AND product_image.order_index = 1
AND product_image.is_deleted = 0
INNER JOIN sellers AS seller
ON seller.account_id = product.seller_id
INNER JOIN product_sales_volumes AS product_sales_volume
ON product_sales_volume.product_id = product.id
WHERE
event_id = %(event_id)s
AND product.is_deleted = 0
AND product.is_display = 1
ORDER BY
product.id DESC
LIMIT %(limit)s
"""
try:
with connection.cursor(pymysql.cursors.DictCursor) as cursor:
cursor.execute(sql, data)
result = cursor.fetchall()
return result
except Exception:
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def get_product_detail_dao(self, connection, data):
""" 상품 상세정보
Args:
connection : 데이터베이스 연결 객체
data : 서비스에서 넘겨 받은 data
Author: 김기용
Returns:
{
"bookmark_count": 0,
"detail_information": "html====================",
"discount_rate": 0.1,
"discounted_price": 9000.0,
"id": 1,
"name": "성보의하루1",
"origin_price": 10000.0,
"sales_count": 40,
"seller_id": 7,
"seller_name": "나는셀러7"
}
Raises:
500, {'message': 'database_error', 'error_message': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
History:
2020-12-31(김기용): 초기 생성
2021-01-01(김기용): 1차 수정: 구현 완료
2021-01-02(김기용): 2차 수정: 북마크 개수 추가
2021-01-03(김기용): 3차 수정: 유저별 북마크 확인기능 추가
2021-01-05(김기용): 4차 수정: 비회원 로그인 북마크 반환값 추가
"""
sql = """
SELECT
product.id AS product_id
, product.name AS product_name
, product.detail_information
, product.seller_id AS seller_id
, seller.name AS seller_name
, product.origin_price
, product.discount_rate
, product.discounted_price
, product_sales_volume.sales_count
, bookmark.bookmark_count
"""
sql_with_account = """
, EXISTS(
SELECT
id
FROM
bookmarks
WHERE
account_id = %(account_id)s
AND product_id= %(product_id)s
AND is_deleted =0
) AS is_bookmarked
"""
sql_without_account = """
FROM
products AS product
INNER JOIN stocks AS stock
ON stock.product_id = product.id
INNER JOIN sellers AS seller
ON product.seller_id = seller.account_id
INNER JOIN product_sales_volumes AS product_sales_volume
ON product_sales_volume.product_id = product.id
INNER JOIN bookmark_volumes AS bookmark
ON bookmark.product_id = product.id
WHERE
product.id = %(product_id)s
AND product.is_deleted = 0
;
"""
try:
with connection.cursor(pymysql.cursors.DictCursor) as cursor:
if 'account_id' not in data:
sql += sql_without_account
cursor.execute(sql, data)
result = cursor.fetchone()
result['is_bookmarked'] = 0
return result
sql += sql_with_account + sql_without_account
cursor.execute(sql, data)
result = cursor.fetchone()
return result
except Exception:
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def get_search_products_dao(self, connection, data):
""" 상품 검색 및 정렬
검색키워드로 상품이름과 셀러이름을 검색하고
검색 결과를 추천순, 판매순, 최신순으로 정렬한다.
Args:
connection : 데이터베이스 연결 객체
data : 서비스에서 넘겨 받은 data
Author: 김기용
Returns: {
"bookmark_count": 0,
"discounted_price": 9000.0,
"image": "https://img.freepik.com",
"name": "성보의하루999",
"origin_price": 10000.0,
"product_id": 999,
"sales_count": 32,
"seller_id": 4,
"seller_name": "나는셀러4"
}
Raises:
500, {'message': 'database_error', 'error_message': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
History:
2020-12-31(김기용): 초기 생성
2021-01-01(김기용): 1차 수정: 정렬기능추가
2021-01-02(김기용): 2차 수정: 북마크 정렬기능 추가
"""
sql = """
SELECT
product_image.image_url AS image
, product.name AS product_name
, product.seller_id AS seller_id
, seller.name AS seller_name
, product.id AS product_id
, product.origin_price
, product.discounted_price
, product_sales_volume.sales_count
, bookmark.bookmark_count
FROM
products AS product
INNER JOIN product_images AS product_image
ON product_id = product_image.product_id
AND product_image.order_index = 1
INNER JOIN sellers AS seller
ON seller.account_id = product.seller_id
INNER JOIN product_sales_volumes AS product_sales_volume
ON product_sales_volume.product_id = product.id
INNER JOIN bookmark_volumes AS bookmark
ON bookmark.product_id = product.id
WHERE
product.name LIKE %(search)s
AND product.is_deleted=0
ORDER BY
(CASE WHEN %(sort_type)s=1 THEN bookmark_count END) DESC
, (CASE WHEN %(sort_type)s=2 THEN sales_count END) DESC
, (CASE WHEN %(sort_type)s=3 THEN product.id END) DESC
LIMIT %(limit)s;
"""
try:
with connection.cursor(pymysql.cursors.DictCursor) as cursor:
data['search'] = '%%' + data['search'] + '%%'
cursor.execute(sql, data)
result = cursor.fetchall()
return result
except Exception:
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')
def get_product_enquiry_list(self, connection, data):
""" 상품 질문 리스트를 조회
Args:
connection: 데이터베이스 연결 객체
data: 서비스에서 넘겨 받은 dict (type, offset, limit)
type = self 혹은 all
offset = 0부터 시작(5단위)
Returns: 질문이 담긴 리스트 반환
[
{
"content": "임시질문인데요2(답변감사합니다)",
"created_at": "2021-01-04 11:31:26",
"enquiry_id": 102,
"enquiry_type_id": 1,
"enquiry_type_name": "상품 문의",
"is_completed": 1,
"is_secret": 0,
"product_id": 1,
"user_id": 152
}
]
Raises:
500, {'message': 'database_error', 'error_message': '서버에 알 수 없는 에러가 발생했습니다.'} : 데이터베이스 에러
History:
2021-01-04(김민구): 초기 생성
"""
sql = """
SELECT
enquiry.id
, enquiry.product_id
, enquiry.user_id
, enquiry.content
, enquiry.enquiry_type_id
, enquiry_type.`name` AS enquiry_type_name
, enquiry.is_secret
, enquiry.is_completed
, enquiry.created_at
FROM
enquiries AS enquiry
INNER JOIN enquiry_types AS enquiry_type
ON enquiry_type.id = enquiry.enquiry_type_id
WHERE
enquiry.product_id = %(product_id)s
AND enquiry.is_deleted = 0
"""
try:
if 'user_id' in data:
sql += '''
AND enquiry.user_id = %(user_id)s
'''
sql += '''
ORDER BY
enquiry.id DESC
LIMIT %(offset)s, %(limit)s
'''
with connection.cursor(pymysql.cursors.DictCursor) as cursor:
cursor.execute(sql, data)
result = cursor.fetchall()
return result
except Exception:
raise DatabaseError('서버에 알 수 없는 에러가 발생했습니다.')