484 lines
11 KiB
Python
484 lines
11 KiB
Python
# coding=utf-8
|
||
# Copyright 2014 Baidu, Inc.
|
||
#
|
||
# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
|
||
# the License. You may obtain a copy of the License at
|
||
#
|
||
# http://www.apache.org/licenses/LICENSE-2.0
|
||
#
|
||
# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
|
||
# an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
|
||
# specific language governing permissions and limitations under the License.
|
||
"""
|
||
This module defines some Argument classes for BTS
|
||
"""
|
||
|
||
|
||
class CreateInstanceArgs(object):
|
||
"""
|
||
Create Instance Args
|
||
:param storage_type instance's storage type. eg.CommonPerformance
|
||
:type storage_type string
|
||
"""
|
||
def __init__(self, storage_type=None):
|
||
self.storage_type = storage_type
|
||
|
||
|
||
def create_instance_args_2_dict(args):
|
||
"""
|
||
change create_instance_args to dict
|
||
|
||
:param args: create instance args
|
||
:type args: CreateInstanceArgs
|
||
|
||
:return:
|
||
:rtype dict
|
||
"""
|
||
return {
|
||
'storageType': args.storage_type
|
||
}
|
||
|
||
|
||
class CreateTableArgs(object):
|
||
"""
|
||
Create Table Args
|
||
:param table_version table's version
|
||
:type table_version int64
|
||
:param compress_type table's compress type. eg.SNAPPY_ALL
|
||
:type compress_type string
|
||
:param ttl time to live
|
||
:type ttl int
|
||
:param storage_type instance's storage type. eg.CommonPerformance
|
||
:type storage_type string
|
||
:param max_versions table's max data versions.
|
||
:type max_versions int
|
||
"""
|
||
def __init__(self, table_version=0, compress_type=None, ttl=0, storage_type=None, max_versions=1):
|
||
self.table_version = table_version
|
||
self.compress_type = compress_type
|
||
self.ttl = ttl
|
||
self.storage_type = storage_type
|
||
self.max_versions = max_versions
|
||
|
||
|
||
def create_table_args_2_dict(args):
|
||
"""
|
||
change create_table_args to dict
|
||
|
||
:param args: create table args
|
||
:type args: CreateTableArgs
|
||
|
||
:return:
|
||
:rtype dict
|
||
"""
|
||
return {
|
||
'tableVersion': args.table_version,
|
||
'compressType': args.compress_type,
|
||
'ttl': args.ttl,
|
||
'storageType': args.storage_type,
|
||
'maxVersions': args.max_versions
|
||
}
|
||
|
||
|
||
class UpdateTableArgs(object):
|
||
"""
|
||
Update Table Args
|
||
:param table_version table's version
|
||
:type table_version int64
|
||
:param compress_type table's compress type. eg.SNAPPY_ALL
|
||
:type compress_type string
|
||
:param ttl time to live
|
||
:type ttl int
|
||
:param max_versions table's max data versions.
|
||
:type max_versions int
|
||
"""
|
||
# 不能将table_version初始化为None，否则后端会认为是创建表
|
||
def __init__(self, table_version=1, compress_type=None, ttl=None, max_versions=None):
|
||
self.table_version = table_version
|
||
self.compress_type = compress_type
|
||
self.ttl = ttl
|
||
self.max_versions = max_versions
|
||
|
||
|
||
def update_table_args_2_dict(args):
|
||
"""
|
||
change update_table_args to dict
|
||
|
||
:param args: update table args
|
||
:type args: UpdateTableArgs
|
||
|
||
:return:
|
||
:rtype dict
|
||
"""
|
||
return {
|
||
'tableVersion': args.table_version,
|
||
'compressType': args.compress_type,
|
||
'ttl': args.ttl,
|
||
'maxVersions': args.max_versions
|
||
}
|
||
|
||
|
||
class Cell(object):
|
||
"""
|
||
Cell
|
||
:param column
|
||
:type column string
|
||
:param value
|
||
:type value string
|
||
"""
|
||
def __init__(self, column="", value=""):
|
||
self.column = column
|
||
self.value = value
|
||
|
||
def to_dict(self):
|
||
"""
|
||
Convert the Cell instance into a dictionary with keys for column and value.
|
||
|
||
:return: A dictionary with 'column' and 'value' as keys, representing
|
||
the cell's data.
|
||
:rtype: dict
|
||
"""
|
||
return {
|
||
'column': self.column,
|
||
'value': self.value
|
||
}
|
||
|
||
|
||
class Row(object):
|
||
"""
|
||
Row
|
||
:param rowkey
|
||
:type rowkey string
|
||
:param cells
|
||
:type cells []
|
||
"""
|
||
def __init__(self, rowkey=""):
|
||
self.rowkey = rowkey
|
||
self.cells = []
|
||
|
||
def append_cell(self, cell):
|
||
"""
|
||
append cell
|
||
|
||
:param cell: column & value
|
||
:type cell: Cell
|
||
|
||
:return:
|
||
:rtype
|
||
"""
|
||
self.cells.append(cell)
|
||
|
||
def get_cell(self):
|
||
"""
|
||
get cell
|
||
|
||
:return cells:
|
||
:rtype Cell[]
|
||
"""
|
||
return self.cells
|
||
|
||
def to_dict(self):
|
||
"""
|
||
Convert the Row instance into a dictionary suitable for serialization.
|
||
|
||
:return: A dictionary with 'rowkey' as the unique identifier and 'cells'
|
||
containing a list of cell data in dictionary form.
|
||
:rtype: dict
|
||
"""
|
||
cells = []
|
||
for cell in self.cells:
|
||
if isinstance(cell, Cell):
|
||
cells.append(cell.to_dict())
|
||
elif isinstance(cell, dict):
|
||
cells.append(cell)
|
||
return {
|
||
'rowkey': self.rowkey,
|
||
'cells': cells
|
||
}
|
||
|
||
|
||
class BatchPutRowArgs(object):
|
||
"""
|
||
Batch Put Row Args
|
||
:param rows
|
||
:type rows []
|
||
"""
|
||
def __init__(self):
|
||
self.rows = []
|
||
|
||
def append_row(self, row):
|
||
"""
|
||
append row
|
||
|
||
:param row:
|
||
:type row: Row
|
||
|
||
:return:
|
||
:rtype
|
||
"""
|
||
self.rows.append(row)
|
||
|
||
def get_row(self):
|
||
"""
|
||
get row
|
||
|
||
:return rows:
|
||
:rtype Row[]
|
||
"""
|
||
return self.rows
|
||
|
||
|
||
class QueryCell(object):
|
||
"""
|
||
Query Cell
|
||
:param column
|
||
:type column string
|
||
"""
|
||
def __init__(self, column=""):
|
||
self.column = column
|
||
|
||
def to_dict(self):
|
||
"""
|
||
Convert the QueryCell instance into a dictionary
|
||
|
||
:return: A dictionary representation of the QueryCell, with 'column' as the key.
|
||
:rtype: dict
|
||
"""
|
||
return {
|
||
'column': self.column,
|
||
}
|
||
|
||
class QueryRowArgs(object):
|
||
"""
|
||
Query Row Arg
|
||
:param rowkey
|
||
:type rowkey string
|
||
:param max_versions
|
||
:type max_versions int
|
||
:param cells
|
||
:type cells []
|
||
"""
|
||
def __init__(self, rowkey="", max_versions=0):
|
||
self.rowkey = rowkey
|
||
self.max_versions = max_versions
|
||
self.cells = []
|
||
|
||
def append_cell(self, cell):
|
||
"""
|
||
append cell
|
||
|
||
:param cell: column & value
|
||
:type cell: Cell
|
||
|
||
:return:
|
||
:rtype
|
||
"""
|
||
self.cells.append(cell)
|
||
|
||
def get_cell(self):
|
||
"""
|
||
get cell
|
||
|
||
:return cells:
|
||
:rtype Cell[]
|
||
"""
|
||
return self.cells
|
||
|
||
def to_dict(self):
|
||
"""
|
||
Convert the QueryRowArgs instance into a dictionary suitable for serialization.
|
||
|
||
:return: A dictionary representation of the QueryRowArgs, including the rowkey and cells.
|
||
:rtype: dict
|
||
"""
|
||
cells_dict = [cell.to_dict() if hasattr(cell, 'to_dict') else cell for cell in self.cells]
|
||
return {
|
||
'rowkey': self.rowkey,
|
||
'cells': cells_dict,
|
||
}
|
||
|
||
|
||
def query_row_args_2_dict(args):
|
||
"""
|
||
change query_row_args to dict
|
||
|
||
:param args: query row args
|
||
:type args: QueryRowArgs
|
||
|
||
:return:
|
||
:rtype dict
|
||
"""
|
||
return {
|
||
'rowkey': args.rowkey,
|
||
'maxVersions': args.max_versions,
|
||
'cells': args.cells
|
||
}
|
||
|
||
|
||
class BatchQueryRowArgs(object):
|
||
"""
|
||
Batch Query Row Args
|
||
:param rows
|
||
:type rows []
|
||
:param max_versions
|
||
:type max_versions int
|
||
"""
|
||
def __init__(self, max_versions=0):
|
||
self.rows = []
|
||
self.max_versions = max_versions
|
||
|
||
def append_row(self, row):
|
||
"""
|
||
append row
|
||
|
||
:param row:
|
||
:type row: Row
|
||
|
||
:return:
|
||
:rtype
|
||
"""
|
||
self.rows.append(row)
|
||
|
||
def get_rows(self):
|
||
"""
|
||
get row
|
||
|
||
:return rows:
|
||
:rtype Row[]
|
||
"""
|
||
return self.rows
|
||
|
||
def to_dict(self):
|
||
"""
|
||
Convert the BatchQueryRowArgs instance to a dictionary for JSON serialization.
|
||
|
||
:return: A dictionary representation of the BatchQueryRowArgs instance with
|
||
'rows' key containing a list of rows and 'max_versions' key
|
||
containing the maximum number of versions.
|
||
:rtype: dict
|
||
"""
|
||
rows_data = []
|
||
for row_arg in self.rows:
|
||
if isinstance(row_arg, QueryRowArgs):
|
||
# Assuming QueryRowArgs has a to_dict method
|
||
row_data = row_arg.to_dict()
|
||
elif isinstance(row_arg, dict):
|
||
row_data = row_arg
|
||
rows_data.append(row_data)
|
||
return {
|
||
'rows': rows_data,
|
||
'max_versions': self.max_versions
|
||
}
|
||
|
||
|
||
def batch_query_row_args_2_dict(args):
|
||
"""
|
||
change batch_query_row_args to dict
|
||
|
||
:param args: batch query row args
|
||
:type args: BatchQueryRowArgs
|
||
|
||
:return:
|
||
:rtype dict
|
||
"""
|
||
return {
|
||
'maxVersions': args.max_versions,
|
||
'rows': args.rows
|
||
}
|
||
|
||
|
||
class ScanArgs(object):
|
||
"""
|
||
Scan Args
|
||
:param start_rowkey
|
||
:type start_rowkey string
|
||
:param include_start
|
||
:type include_start bool
|
||
:param stop_rowkey
|
||
:type stop_rowkey string
|
||
:param include_stop
|
||
:type include_stop bool
|
||
:param limit
|
||
:type limit int
|
||
:param max_versions
|
||
:type max_versions int
|
||
:param selector
|
||
:type selector []
|
||
"""
|
||
def __init__(self, start_rowkey="", include_start=True, stop_rowkey="",
|
||
include_stop=False, limit=0, max_versions=0):
|
||
self.start_rowkey = start_rowkey
|
||
self.include_start = include_start
|
||
self.stop_rowkey = stop_rowkey
|
||
self.include_stop = include_stop
|
||
self.limit = limit
|
||
self.max_versions = max_versions
|
||
self.selector = []
|
||
|
||
def append_selector(self, query_cell):
|
||
"""
|
||
append selector
|
||
|
||
:param query_cell:
|
||
:type query_cell: QueryCell
|
||
|
||
:return:
|
||
:rtype
|
||
"""
|
||
self.selector.append(query_cell)
|
||
|
||
def get_selector(self):
|
||
"""
|
||
get selector
|
||
|
||
:return selector:
|
||
:rtype query_cell[]
|
||
"""
|
||
return self.selector
|
||
|
||
def to_dict(self):
|
||
"""
|
||
Convert the ScanArgs instance into a dictionary
|
||
|
||
:return: A dictionary representation of the scan arguments.
|
||
:rtype: dict
|
||
"""
|
||
selector = []
|
||
for item in self.selector:
|
||
if isinstance(item, QueryCell):
|
||
selector.append({'column': item.column})
|
||
elif isinstance(item, dict):
|
||
selector.append(item)
|
||
|
||
return {
|
||
'startRowkey': self.start_rowkey,
|
||
'includeStart': self.include_start,
|
||
'stopRowkey': self.stop_rowkey,
|
||
'includeStop': self.include_stop,
|
||
'selector': selector,
|
||
'maxVersions': self.max_versions,
|
||
'limit': self.limit
|
||
}
|
||
|
||
|
||
def scan_args_2_dict(args):
|
||
"""
|
||
change scan_args to dict
|
||
|
||
:param args: scan row args
|
||
:type args: ScanArgs
|
||
|
||
:return:
|
||
:rtype dict
|
||
"""
|
||
return {
|
||
'startRowkey': args.start_rowkey,
|
||
'includeStart': args.include_start,
|
||
'stopRowkey': args.stop_rowkey,
|
||
'includeStop': args.include_stop,
|
||
'selector': args.selector,
|
||
'limit': args.limit,
|
||
'maxVersions': args.max_versions
|
||
}
|
||
|