SequoiaDB
All Classes Functions
Public Member Functions | List of all members
pysequoiadb.collection.collection Class Reference
Inheritance diagram for pysequoiadb.collection.collection:

Public Member Functions

def __init__
 
def __del__
 
def __repr__
 
def get_count
 
def split_by_condition
 
def split_by_percent
 
def split_async_by_condition
 
def split_async_by_percent
 
def bulk_insert
 
def insert
 
def update
 
def upsert
 
def delete
 
def query
 
def query_and_update
 
def query_and_remove
 
def create_index
 
def get_indexes
 
def drop_index
 
def get_collection_name
 
def get_cs_name
 
def get_full_name
 
def aggregate
 
def get_query_meta
 
def attach_collection
 
def detach_collection
 
def create_lob
 
def get_lob
 
def remove_lob
 
def list_lobs
 
def query_one
 
def explain
 
def truncate
 
def create_id_index
 
def drop_id_index
 

Detailed Description

Collection for SequoiaDB

All operation need deal with the error code returned first, if it has.
Every error code is not SDB_OK(or 0), it means something error has appeared,
and user should deal with it according the meaning of error code printed.

@version: execute to get version
          >>> import pysequoiadb
          >>> print pysequoiadb.get_version()

@notice : The dict of built-in Python is hashed and non-ordered. so the
          element in dict may not the order we make it. we make a dict and
          print it like this:
          ...
          >>> a = {"avg_age":24, "major":"computer science"}
          >>> a
          >>> {'major': 'computer science', 'avg_age': 24}
          ...
          the elements order it is not we make it!!
          therefore, we use bson.SON to make the order-sensitive dict if the
          order is important such as operations in "$sort", "$group",
          "split_by_condition", "aggregate","create_collection"...
          In every scene which the order is important, please make it using
          bson.SON and list. It is a subclass of built-in dict
          and order-sensitive

Constructor & Destructor Documentation

def pysequoiadb.collection.collection.__init__ (   self)
create a new collection.

Exceptions:
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.__del__ (   self)
delete a object existed.

Exceptions:
   pysequoiadb.error.SDBBaseError

Member Function Documentation

def pysequoiadb.collection.collection.aggregate (   self,
  aggregate_options 
)
Execute aggregate operation in specified collection.

Parameters:
   Name               Type       Info:
   aggregate_options  list/tuple The array of dict objects.
                                 bson.SON may need if the element is
                                 order-sensitive.
                                 eg.
                                 {'$sort':bson.SON([("name",-1), ("age":1)])}
                                 it will be ordered descending by 'name'
                                 first, and be ordered ascending by 'age'
Return values:
   a cursor object of result
Exceptions:
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.attach_collection (   self,
  cl_full_name,
  options 
)
Attach the specified collection.

Parameters:
   Name            Type  Info:
   subcl_full_name str   The name fo the subcollection.
   options         dict  he low boudary and up boudary
                         eg: {"LowBound":{a:1},"UpBound":{a:100}}
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.bulk_insert (   self,
  flags,
  records 
)
Insert a bulk of record into current collection.

Parameters:
   Name        Type       Info:
   flags       int        0 or 1, see Info as below.
   records     list/tuple The list of inserted records.
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
Info:
   flags : 0 or 1.
   0 : stop insertting when hit index key duplicate error
   1 : continue insertting records even though index key duplicate error hit
def pysequoiadb.collection.collection.create_index (   self,
  index_def,
  idx_name,
  is_unique,
  is_enforced,
  buffer_size = 64 
)
Create an index in current collection.

Parameters:
   Name         Type  Info:
   index_def    dict  The dict object of index element.
                      e.g. {'name':1, 'age':-1}
   idx_name     str   The index name.
   is_unique    bool  Whether the index elements are unique or not.
   is_enforced  bool  Whether the index is enforced unique This
                      element is meaningful when isUnique is set to
                      true.
   buffer_size  int   The size of sort buffer used when creating index,
                      the unit is MB, zero means don't use sort buffer
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.create_lob (   self,
  oid = None 
)
create lob.

Parameters:
   Name     Type           Info:
   oid      bson.ObjectId  Specified the oid of lob to be created,
                           if None, the oid is generated automatically
Return values:
   a lob object
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.delete (   self,
  kwargs 
)
Delete the matching documents in current collection.

Parameters:
   Name        Type  Info:
   **kwargs          Useful options are below
   - condition dict  The matching rule, delete all the documents
                     if not provided.
   - hint      dict  The hint, automatically match the optimal hint
                     if not provided
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.detach_collection (   self,
  sub_cl_full_name 
)
Dettach the specified collection.

Parameters:
   Name            Type  Info:
   subcl_full_name str   The name fo the subcollection.
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.drop_index (   self,
  idx_name 
)
The index name.

Parameters:
   Name         Type  Info:
   idx_name     str   The index name.
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.explain (   self,
  kwargs 
)
Get the matching documents in current collection.

Parameters:
   Name              Type     Info:
   **kwargs                   Useful options are below
   - condition       dict     The matching rule, update all the
                              documents if not provided.
   - selected        dict     The selective rule, return the whole
                              document if not provided.
   - order_by        dict     The ordered rule, result set is unordered
                              if not provided.
   - hint            dict     The hint, automatically match the optimal
                              hint if not provided.
   - num_to_skip     long     Skip the first numToSkip documents,
                              default is 0L.
   - num_to_return   long     Only return numToReturn documents,
                              default is -1L for returning
                              all results.
   - flag            int
   - options         json
Return values:
   a cursor object of query
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.get_collection_name (   self)
Get the name of specified collection in current collection space.

Return values:
   The name of specified collection
Exceptions:
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.get_count (   self,
  condition = None 
)
Get the count of matching documents in current collection.

Parameters:
   Name         Type     Info:
   condition    dict     The matching rule, return the count of all
                         documents if None.
Return values:
   count of result
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.get_cs_name (   self)
Get the name of current collection space.

Return values:
   The name of current collection space
Exceptions:
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.get_full_name (   self)
Get the full name of specified collection in current collection space.

Return values:
   The full name of current collection
Exceptions:
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.get_indexes (   self,
  idx_name = None 
)
Get all of or one of the indexes in current collection.

Parameters:
   Name         Type  Info:
   idx_name     str   The index name, returns all of the indexes
                      if this parameter is None.
Return values:
   a cursor object of result
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.get_lob (   self,
  oid 
)
get the specified lob.

Parameters:
   Name     Type                 Info:
   oid      str/bson.ObjectId    The specified oid
Return values:
   a lob object
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.get_query_meta (   self,
  kwargs 
)
Get the index blocks' or data blocks' infomations for concurrent query.

Parameters:
   Name              Type     Info:
   **kwargs                   Useful options are below
   - condition       dict     The matching rule, return the whole range
                              of index blocks if not provided.
                              eg:{"age":{"$gt":25},"age":{"$lt":75}}.
   - order_by        dict     The ordered rule, result set is unordered
                              if not provided.bson.SON may need if it is
                              order-sensitive.
   - hint            dict     One of the indexs in current collection,
                              using default index to query if not
                              provided.
                              eg:{"":"ageIndex"}.
   - num_to_skip     long     Skip the first num_to_skip documents,
                              default is 0L.
   - num_to_return   long     Only return num_to_return documents,
                              default is -1L for returning all results.
Return values:
   a cursor object of query
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.insert (   self,
  record 
)
Insert a record into current collection.

Parameters:
   Name      Type    Info:
   records   dict    The inserted record.
Return values:
   ObjectId of record inserted
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.list_lobs (   self)
list all lobs.

Parameters:
   Name     Type                 Info:

Return values:
   a cursor object of query
Exceptions:
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.query (   self,
  kwargs 
)
Get the matching documents in current collection.

Parameters:
   Name              Type     Info:
   **kwargs                   Useful options are below
   - condition       dict     The matching rule, update all the
                              documents if not provided.
   - selector        dict     The selective rule, return the whole
                              document if not provided.
   - order_by        dict     The ordered rule, result set is unordered
                              if not provided.
   - hint            dict     The hint, automatically match the optimal
                              hint if not provided.
   - num_to_skip     long     Skip the first numToSkip documents,
                              default is 0L.
   - num_to_return   long     Only return numToReturn documents,
                              default is -1L for returning
                              all results.
Return values:
   a cursor object of query
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.query_and_remove (   self,
  condition = None,
  selector = None,
  order_by = None,
  hint = None,
  num_to_skip = 0,
  num_to_return = -1 
)
Get the matching documents in current collection and remove.

Parameters:
   Name            Type     Info:
   condition       dict     The matching rule, update all the
                              documents if not provided.
   selector        dict     The selective rule, return the whole
                              document if not provided.
   order_by        dict     The ordered rule, result set is unordered
                              if not provided.
   hint            dict     The hint, automatically match the optimal
                              hint if not provided.
   num_to_skip     long     Skip the first numToSkip documents,
                              default is 0L.
   num_to_return   long     Only return numToReturn documents,
                              default is -1L for returning
                              all results.
Return values:
   a cursor object of query
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.query_and_update (   self,
  update,
  condition = None,
  selector = None,
  order_by = None,
  hint = None,
  num_to_skip = 0,
  num_to_return = -1,
  return_new = False 
)
Get the matching documents in current collection and update.

Parameters:
   Name            Type     Info:
   update          dict     The update rule, can't be null.
   condition       dict     The matching rule, update all the
                              documents if not provided.
   selector        dict     The selective rule, return the whole
                              document if not provided.
   order_by        dict     The ordered rule, result set is unordered
                              if not provided.
   hint            dict     The hint, automatically match the optimal
                              hint if not provided.
   num_to_skip     long     Skip the first numToSkip documents,
                              default is 0L.
   num_to_return   long     Only return numToReturn documents,
                              default is -1L for returning
                              all results.
   return_new      bool     When True, returns the updated document rather than the original
Return values:
   a cursor object of query
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.query_one (   self,
  kwargs 
)
Get one matching documents in current collection.

Parameters:
   Name              Type     Info:
   **kwargs                   Useful options are below
   - condition       dict     The matching rule, update all the
                              documents if not provided.
   - selected        dict     The selective rule, return the whole
                              document if not provided.
   - order_by        dict     The ordered rule, result set is unordered
                              if not provided.
   - hint            dict     The hint, automatically match the optimal
                              hint if not provided.
   - num_to_skip     long     Skip the first numToSkip documents,
                              default is 0L.
Return values:
   a record of json/dict
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.remove_lob (   self,
  oid 
)
remove lob.

Parameters:
   Name     Type                 Info:
   oid      str/bson.ObjectId    The oid of the lob to be remove.
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.split_async_by_condition (   self,
  source_group_name,
  target_group_name,
  split_condition,
  split_end_condition = None 
)
Split the specified collection from source replica group to target
   replica group by range.

Parameters:
   Name                  Type  Info:
   source_group_name     str   The source replica group name.
   target_group_name     str   The target replica group name.
   split_condition       dict  The matching rule, return the count of
                               all documents if None.
   split_end_condition   dict  The split end condition or None.
                               eg:
                               If we create a collection with the
                               option { ShardingKey:{"age":1},
                               ShardingType:"Hash",Partition:2^10 },
                               we can fill {age:30} as the
                               splitCondition, and fill {age:60}
                               as the splitEndCondition. when split,
                               the target replica group will get the
                               records whose age's hash value are in
                               [30,60). If splitEndCondition is null,
                               they are in [30,max).
Return values:
   task id
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.split_async_by_percent (   self,
  source_group_name,
  target_group_name,
  percent 
)
Split the specified collection from source replica group to target
   replica group by percent.

Parameters:
   Name               Type     Info:
   source_group_name  str      The source replica group name.
   target_group_name  str      The target replica group name.
   percent                float    The split percent, Range:(0,100]
Return values:
   task id
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.split_by_condition (   self,
  source_group_name,
  target_group_name,
  split_condition,
  split_end_condition = None 
)
Split the specified collection from source replica group to target
   replica group by range.

Parameters:
   Name                  Type     Info:
   source_group_name     str      The source replica group name.
   target_group_name     str      The target replica group name.
   split_condition       dict     The matching rule, return the count
                                  of all documents if None.
   split_end_condition   dict     The split end condition or None.
                                  eg:
                                  If we create a collection with the
                                  option { ShardingKey:{"age":1},
                                  ShardingType:"Hash",Partition:2^10 },
                                  we can fill {age:30} as the
                                  splitCondition, and fill {age:60}
                                  as the splitEndCondition. when
                                  split, the target replica group
                                  will get the records whose age's
                                  hash value are in [30,60).
                                  If splitEndCondition is null, they
                                  are in [30,max).
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.split_by_percent (   self,
  source_group_name,
  target_group_name,
  percent 
)
Split the specified collection from source replica group to target
   replica group by percent.

Parameters:
   Name               Type     Info:
   source_group_name  str      The source replica group name.
   target_group_name  str      The target replica group name.
   percent                float    The split percent, Range:(0,100]
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
def pysequoiadb.collection.collection.update (   self,
  rule,
  kwargs 
)
Update the matching documents in current collection.

Parameters:
   Name        Type     Info:
   rule        dict     The updating rule.
   **kwargs             Useful option are below
   - condition dict     The matching rule, update all the documents
                        if not provided.
   - hint      dict     The hint, automatically match the optimal hint
                        if not provided
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
Note:
   It won't work to update the "ShardingKey" field, but the other fields
   take effect.
def pysequoiadb.collection.collection.upsert (   self,
  rule,
  kwargs 
)
Update the matching documents in current collection, insert if
   no matching.

Parameters:
   Name          Type  Info:
   rule          dict  The updating rule.
   **kwargs            Useful options are below
   - condition   dict  The matching rule, update all the documents
                       if not provided.
   - hint        dict  The hint, automatically match the optimal hint
                       if not provided
   - setOnInsert dict  The setOnInsert assigns the specified values to the fileds when insert
Exceptions:
   pysequoiadb.error.SDBTypeError
   pysequoiadb.error.SDBBaseError
Note:
   It won't work to update the "ShardingKey" field, but the other fields
   take effect.

The documentation for this class was generated from the following file: