Hello community, here is the log from the commit of package python-happybase for openSUSE:Factory checked in at 2014-04-17 14:08:40 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-happybase (Old) and /work/SRC/openSUSE:Factory/.python-happybase.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-happybase" Changes: -------- --- /work/SRC/openSUSE:Factory/python-happybase/python-happybase.changes 2013-12-11 16:21:30.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.python-happybase.new/python-happybase.changes 2014-04-17 14:08:41.000000000 +0200 @@ -1,0 +2,10 @@ +Tue Apr 15 21:00:40 UTC 2014 - dmuel...@suse.com + +- update to 0.8: + * Add (and default to) '0.96' compatibility mode in :py:class:`Connection`. + * Add support for retrieving sorted columns, which is possible with the HBase + 0.96 Thrift API + * The `batch_size` argument to :py:meth:`Table.scan` is no longer propagated to + `Scan.setBatching()` at the Java side (inside the Thrift server). + +------------------------------------------------------------------- Old: ---- happybase-0.7.tar.gz New: ---- happybase-0.8.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-happybase.spec ++++++ --- /var/tmp/diff_new_pack.4RaE2F/_old 2014-04-17 14:08:41.000000000 +0200 +++ /var/tmp/diff_new_pack.4RaE2F/_new 2014-04-17 14:08:41.000000000 +0200 @@ -1,7 +1,7 @@ # # spec file for package python-happybase # -# Copyright (c) 2013 SUSE LINUX Products GmbH, Nuernberg, Germany. +# Copyright (c) 2014 SUSE LINUX Products GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -17,13 +17,13 @@ Name: python-happybase -Version: 0.7 +Version: 0.8 Release: 0 Summary: A developer-friendly Python library to interact with Apache HBase License: MIT Group: Development/Languages/Python Url: https://github.com/wbolster/happybase -Source: http://pypi.python.org/packages/source/h/happybase/happybase-%{version}.tar.gz +Source: https://pypi.python.org/packages/source/h/happybase/happybase-%{version}.tar.gz BuildRequires: python-Sphinx BuildRequires: python-devel BuildRequires: python-setuptools ++++++ happybase-0.7.tar.gz -> happybase-0.8.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/happybase-0.7/NEWS.rst new/happybase-0.8/NEWS.rst --- old/happybase-0.7/NEWS.rst 2013-11-06 23:16:45.000000000 +0100 +++ new/happybase-0.8/NEWS.rst 2014-02-25 21:15:11.000000000 +0100 @@ -4,6 +4,29 @@ .. py:currentmodule:: happybase +HappyBase 0.8 +------------- + +Release date: 2014-02-25 + +* Add (and default to) '0.96' compatibility mode in :py:class:`Connection`. + +* Add support for retrieving sorted columns, which is possible with the HBase + 0.96 Thrift API. This feature uses a new `sorted_columns` argument to + :py:meth:`Table.scan`. An ```OrderedDict`` implementation is required for this + feature; with Python 2.7 this is available from the standard library, but for + Python 2.6 a separate ```ordereddict``` pacakge has to be installed from PyPI. + (`issue #39 <https://github.com/wbolster/happybase/issues/39>`_) + +* The `batch_size` argument to :py:meth:`Table.scan` is no longer propagated to + `Scan.setBatching()` at the Java side (inside the Thrift server). To influence + the `Scan.setBatching()` (which may split rows into partial rows) a new + `scan_batching` argument to :py:meth:`Table.scan` has been added. See `issue + #54 <https://github.com/wbolster/happybase/issues/54>`_, `issue #56 + <https://github.com/wbolster/happybase/issues/56>`_, and the HBase docs for + `Scan.setBatching()` for more details. + + HappyBase 0.7 ------------- @@ -12,7 +35,7 @@ * Added a `wal` argument to various data manipulation methods on the :py:class:`Table` and :py:class:`Batch` classes to determine whether to write the mutation to the Write-Ahead Log (WAL). (`issue #36 - <https://github.com/wbolster/happybase/issues/36>`_). + <https://github.com/wbolster/happybase/issues/36>`_) * Pass batch_size to underlying Thrift Scan instance (`issue #38 <https://github.com/wbolster/happybase/issues/38>`_). diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/happybase-0.7/PKG-INFO new/happybase-0.8/PKG-INFO --- old/happybase-0.7/PKG-INFO 2013-11-06 23:20:23.000000000 +0100 +++ new/happybase-0.8/PKG-INFO 2014-02-25 21:19:38.000000000 +0100 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: happybase -Version: 0.7 +Version: 0.8 Summary: A developer-friendly Python library to interact with Apache HBase Home-page: https://github.com/wbolster/happybase Author: Wouter Bolsterlee diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/happybase-0.7/doc/user.rst new/happybase-0.8/doc/user.rst --- old/happybase-0.7/doc/user.rst 2013-11-03 17:50:17.000000000 +0100 +++ new/happybase-0.8/doc/user.rst 2014-01-25 21:51:13.000000000 +0100 @@ -30,11 +30,11 @@ In some setups, the :py:class:`Connection` class needs some additional information about the HBase version it will be connecting to, and which Thrift transport to use. If you're still using HBase 0.90.x, you need to set the -`compat` parameter to make sure HappyBase speaks the correct wire protocol. +`compat` argument to make sure HappyBase speaks the correct wire protocol. Additionally, if you're using HBase 0.94 with a non-standard Thrift transport -mode, make sure to supply the right `transport` parameter. See the API +mode, make sure to supply the right `transport` argument. See the API documentation for the :py:class:`Connection` class for more information about -these parameters and their supported values. +these arguments and their supported values. When a :py:class:`Connection` is created, it automatically opens a socket connection to the HBase Thrift server. This behaviour can be disabled by @@ -116,7 +116,7 @@ ``myproject_XYZ``. Instead of adding this application-specific prefix each time a table name is -passed to HappyBase, the `table_prefix` parameter to :py:class:`Connection` can +passed to HappyBase, the `table_prefix` argument to :py:class:`Connection` can take care of this. HappyBase will prepend that prefix (and an underscore) to each table name handled by that :py:class:`Connection` instance. For example:: @@ -211,7 +211,7 @@ By default, HappyBase does not include timestamps in the results it returns. In your application needs access to the timestamps, simply set the -`include_timestamp` parameter to ``True``. Now, each cell in the result will be +`include_timestamp` argument to ``True``. Now, each cell in the result will be returned as a `(value, timestamp)` tuple instead of just a value:: row = table.row('row-key', columns=['cf1:col1'], include_timestamp=True) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/happybase-0.7/happybase/_version.py new/happybase-0.8/happybase/_version.py --- old/happybase-0.7/happybase/_version.py 2013-11-06 23:09:14.000000000 +0100 +++ new/happybase-0.8/happybase/_version.py 2014-02-25 21:19:18.000000000 +0100 @@ -5,4 +5,4 @@ setup.py. """ -__version__ = '0.7' +__version__ = '0.8' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/happybase-0.7/happybase/connection.py new/happybase-0.8/happybase/connection.py --- old/happybase-0.7/happybase/connection.py 2013-11-03 17:50:17.000000000 +0100 +++ new/happybase-0.8/happybase/connection.py 2014-01-25 21:52:24.000000000 +0100 @@ -17,7 +17,7 @@ logger = logging.getLogger(__name__) -COMPAT_MODES = ('0.90', '0.92', '0.94') +COMPAT_MODES = ('0.90', '0.92', '0.94', '0.96') THRIFT_TRANSPORTS = dict( buffered=TBufferedTransport, framed=TFramedTransport, @@ -26,50 +26,52 @@ DEFAULT_HOST = 'localhost' DEFAULT_PORT = 9090 DEFAULT_TRANSPORT = 'buffered' -DEFAULT_COMPAT = '0.94' +DEFAULT_COMPAT = '0.96' class Connection(object): """Connection to an HBase Thrift server. - The `host` and `port` parameters specify the host name and TCP port + The `host` and `port` arguments specify the host name and TCP port of the HBase Thrift server to connect to. If omitted or ``None``, a connection to the default port on ``localhost`` is made. If - specifed, the `timeout` parameter specifies the socket timeout in + specifed, the `timeout` argument specifies the socket timeout in milliseconds. - If `autoconnect` is `True` (the default) the connection is made directly, - otherwise :py:meth:`Connection.open` must be called explicitly before first - use. - - The optional `table_prefix` and `table_prefix_separator` arguments specify - a prefix and a separator string to be prepended to all table names, e.g. - when :py:meth:`Connection.table` is invoked. For example, if `table_prefix` - is ``myproject``, all tables tables will have names like ``myproject_XYZ``. - - The optional `compat` parameter sets the compatibility level for this - connection. Older HBase versions have slightly different Thrift interfaces, - and using the wrong protocol can lead to crashes caused by communication - errors, so make sure to use the correct one. This value can be either the - string ``0.92`` (the default) for use with HBase 0.92.x and later versions, - or ``0.90`` for use with HBase 0.90.x. - - The optional `transport` parameter specifies the Thrift transport mode to - use. Supported values for this parameter are ``buffered`` (the default) and - ``framed``. Make sure to choose the right one, since otherwise you might - see non-obvious connection errors or program hangs when making - a connection. HBase versions before 0.94 always use the buffered transport. - Starting with HBase 0.94, the Thrift server optionally uses a framed - transport, depending on the parameter passed to the ``hbase-daemon.sh start - thrift`` command. The default ``-threadpool`` mode uses the buffered - transport; the ``-hsha``, ``-nonblocking``, and ``-threadedselector`` modes - use the framed transport. + If `autoconnect` is `True` (the default) the connection is made + directly, otherwise :py:meth:`Connection.open` must be called + explicitly before first use. + + The optional `table_prefix` and `table_prefix_separator` arguments + specify a prefix and a separator string to be prepended to all table + names, e.g. when :py:meth:`Connection.table` is invoked. For + example, if `table_prefix` is ``myproject``, all tables tables will + have names like ``myproject_XYZ``. + + The optional `compat` argument sets the compatibility level for + this connection. Older HBase versions have slightly different Thrift + interfaces, and using the wrong protocol can lead to crashes caused + by communication errors, so make sure to use the correct one. This + value can be either the string ``0.90``, ``0.92``, ``0.94``, or + ``0.96`` (the default). + + The optional `transport` argument specifies the Thrift transport + mode to use. Supported values for this argument are ``buffered`` + (the default) and ``framed``. Make sure to choose the right one, + since otherwise you might see non-obvious connection errors or + program hangs when making a connection. HBase versions before 0.94 + always use the buffered transport. Starting with HBase 0.94, the + Thrift server optionally uses a framed transport, depending on the + argument passed to the ``hbase-daemon.sh start thrift`` command. + The default ``-threadpool`` mode uses the buffered transport; the + ``-hsha``, ``-nonblocking``, and ``-threadedselector`` modes use the + framed transport. .. versionadded:: 0.5 - `timeout` parameter + `timeout` argument .. versionadded:: 0.4 - `table_prefix_separator` parameter + `table_prefix_separator` argument .. versionadded:: 0.4 support for framed Thrift transports @@ -177,16 +179,17 @@ def table(self, name, use_prefix=True): """Return a table object. - Returns a :py:class:`happybase.Table` instance for the table named - `name`. This does not result in a round-trip to the server, and the - table is not checked for existence. - - The optional `use_prefix` parameter specifies whether the table prefix - (if any) is prepended to the specified `name`. Set this to `False` if - you want to use a table that resides in another ‘prefix namespace’, - e.g. a table from a ‘friendly’ application co-hosted on the same HBase - instance. See the `table_prefix` parameter to the - :py:class:`Connection` constructor for more information. + Returns a :py:class:`happybase.Table` instance for the table + named `name`. This does not result in a round-trip to the + server, and the table is not checked for existence. + + The optional `use_prefix` argument specifies whether the table + prefix (if any) is prepended to the specified `name`. Set this + to `False` if you want to use a table that resides in another + ‘prefix namespace’, e.g. a table from a ‘friendly’ application + co-hosted on the same HBase instance. See the `table_prefix` + argument to the :py:class:`Connection` constructor for more + information. :param str name: the name of the table :param bool use_prefix: whether to use the table prefix (if any) @@ -226,7 +229,7 @@ :param str name: The table name :param dict families: The name and options for each column family - The `families` parameter is a dictionary mapping column family + The `families` argument is a dictionary mapping column family names to a dictionary containing the options for this column family, e.g. @@ -283,11 +286,11 @@ """Delete the specified table. .. versionadded:: 0.5 - the `disable` parameter + `disable` argument - In HBase, a table always needs to be disabled before it can be deleted. - If the `disable` parameter is `True`, this method first disables the - table if it wasn't already and then deletes it. + In HBase, a table always needs to be disabled before it can be + deleted. If the `disable` argument is `True`, this method first + disables the table if it wasn't already and then deletes it. :param str name: The table name :param bool disable: Whether to first disable the table if needed diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/happybase-0.7/happybase/pool.py new/happybase-0.8/happybase/pool.py --- old/happybase-0.7/happybase/pool.py 2013-06-21 15:40:35.000000000 +0200 +++ new/happybase-0.8/happybase/pool.py 2014-01-25 21:51:13.000000000 +0100 @@ -40,7 +40,7 @@ .. versionadded:: 0.5 - The `size` parameter specifies how many connections this pool + The `size` argument specifies how many connections this pool manages. Additional keyword arguments are passed unmodified to the :py:class:`happybase.Connection` constructor, with the exception of the `autoconnect` argument, since maintaining connections is the diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/happybase-0.7/happybase/table.py new/happybase-0.8/happybase/table.py --- old/happybase-0.7/happybase/table.py 2013-11-06 22:46:27.000000000 +0100 +++ new/happybase-0.8/happybase/table.py 2014-02-25 21:19:18.000000000 +0100 @@ -8,7 +8,7 @@ from struct import Struct from .hbase.ttypes import TScan -from .util import thrift_type_to_dict, str_increment +from .util import thrift_type_to_dict, str_increment, OrderedDict from .batch import Batch logger = logging.getLogger(__name__) @@ -24,6 +24,14 @@ return dict((cn, cellfn(cell)) for cn, cell in cell_map.iteritems()) +def make_ordered_row(sorted_columns, include_timestamp): + """Make a row dict for sorted column results from scans.""" + cellfn = include_timestamp and make_cell_timestamp or make_cell + return OrderedDict( + (column.columnName, cellfn(column.cell)) + for column in sorted_columns) + + class Table(object): """HBase table abstraction class. @@ -50,13 +58,14 @@ descriptors = self.connection.client.getColumnDescriptors(self.name) families = dict() for name, descriptor in descriptors.items(): - name = name[:-1] # drop trailing ':' + name = name.rstrip(':') families[name] = thrift_type_to_dict(descriptor) return families def _column_family_names(self): """Retrieve the column family names for this table (internal use)""" - return self.connection.client.getColumnDescriptors(self.name).keys() + names = self.connection.client.getColumnDescriptors(self.name).keys() + return [name.rstrip(':') for name in names] def regions(self): """Retrieve the regions for this table. @@ -184,10 +193,10 @@ if versions is None: versions = (2 ** 31) - 1 # Thrift type is i32 elif not isinstance(versions, int): - raise TypeError("'versions' parameter must be a number or None") + raise TypeError("'versions' argument must be a number or None") elif versions < 1: raise ValueError( - "'versions' parameter must be at least 1 (or None)") + "'versions' argument must be at least 1 (or None)") if timestamp is None: cells = self.connection.client.getVer( @@ -205,7 +214,8 @@ def scan(self, row_start=None, row_stop=None, row_prefix=None, columns=None, filter=None, timestamp=None, - include_timestamp=False, batch_size=1000, limit=None): + include_timestamp=False, batch_size=1000, scan_batching=None, + limit=None, sorted_columns=False): """Create a scanner for data in the table. This method returns an iterable that can be used for looping over the @@ -240,9 +250,28 @@ this to a low value (or even 1) if your data is large, since a low batch size results in added round-trips to the server. - **Compatibility note:** The `filter` argument is only available when - using HBase 0.92 (or up). In HBase 0.90 compatibility mode, specifying - a `filter` raises an exception. + The optional `scan_batching` is for advanced usage only; it + translates to `Scan.setBatching()` at the Java side (inside the + Thrift server). By setting this value rows may be split into + partial rows, so result rows may be incomplete, and the number + of results returned by te scanner may no longer correspond to + the number of rows matched by the scan. + + If `sorted_columns` is `True`, the columns in the rows returned + by this scanner will be retrieved in sorted order, and the data + will be stored in `OrderedDict` instances. + + **Compatibility notes:** + + * The `filter` argument is only available when using HBase 0.92 + (or up). In HBase 0.90 compatibility mode, specifying + a `filter` raises an exception. + + * The `sorted_columns` argument is only available when using + HBase 0.96 (or up). + + .. versionadded:: 0.8 + `sorted_columns` argument :param str row_start: the row key to start at (inclusive) :param str row_stop: the row key to stop at (exclusive) @@ -252,6 +281,9 @@ :param int timestamp: timestamp (optional) :param bool include_timestamp: whether timestamps are returned :param int batch_size: batch size for retrieving resuls + :param bool scan_batching: server-side scan batching (optional) + :param int limit: max number of rows to return + :param bool sorted_columns: whether to return sorted columns :return: generator yielding the rows matching the scan :rtype: iterable of `(row_key, row_data)` tuples @@ -262,6 +294,10 @@ if limit is not None and limit < 1: raise ValueError("'limit' must be >= 1") + if sorted_columns and self.connection.compat < '0.96': + raise NotImplementedError( + "'sorted_columns' is not supported in HBase >= 0.96") + if row_prefix is not None: if row_start is not None or row_stop is not None: raise TypeError( @@ -299,10 +335,25 @@ self.name, row_start, row_stop, columns, timestamp, {}) else: - # The scan's caching size is set to the batch_size, so that - # the HTable on the Java side retrieves rows from the region - # servers in the same chunk sizes that it sends out over - # Thrift. + # XXX: The "batch_size" can be slightly confusing to those + # familiar with the HBase Java API: + # + # * TScan.caching (Thrift API) translates to + # Scan.setCaching() (Java API) + # + # * TScan.batchSize (Thrift API) translates to + # Scan.setBatching (Java API) . + # + # However, we set Scan.setCaching() to what is called + # batch_size in the HappyBase API, so that the HTable on the + # Java side (inside the Thrift server) retrieves rows from + # the region servers in the same chunk sizes that it sends + # out again to Python (over Thrift). This cannot be tweaked + # (by design). + # + # The Scan.setBatching() value (Java API), which possibly + # cuts rows into multiple partial rows, can be set using the + # slightly strange name scan_batching. scan = TScan( startRow=row_start, stopRow=row_stop, @@ -310,7 +361,8 @@ columns=columns, caching=batch_size, filterString=filter, - batchSize=batch_size, + batchSize=scan_batching, + sortColumns=sorted_columns, ) scan_id = self.connection.client.scannerOpenWithScan( self.name, scan, {}) @@ -334,7 +386,14 @@ n_fetched += len(items) for n_returned, item in enumerate(items, n_returned + 1): - yield item.row, make_row(item.columns, include_timestamp) + if sorted_columns: + row = make_ordered_row(item.sortedColumns, + include_timestamp) + else: + row = make_row(item.columns, include_timestamp) + + yield item.row, row + if limit is not None and n_returned == limit: return @@ -364,7 +423,7 @@ method to manipulate data. .. versionadded:: 0.7 - `wal` parameter + `wal` argument :param str row: the row key :param dict data: the data to store @@ -384,7 +443,7 @@ method to manipulate data. .. versionadded:: 0.7 - `wal` parameter + `wal` argument :param str row: the row key :param list_or_tuple columns: list of columns (optional) @@ -420,7 +479,7 @@ :py:meth:`Batch.delete`. .. versionadded:: 0.7 - `wal` parameter + `wal` argument :param bool transaction: whether this batch should behave like a transaction (only useful when used as a diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/happybase-0.7/happybase/util.py new/happybase-0.8/happybase/util.py --- old/happybase-0.7/happybase/util.py 2013-11-06 22:46:27.000000000 +0100 +++ new/happybase-0.8/happybase/util.py 2014-01-25 21:51:13.000000000 +0100 @@ -9,6 +9,21 @@ CAPITALS = re.compile('([A-Z])') +try: + # Python 2.7 + from collections import OrderedDict +except ImportError: + try: + # External package for Python 2.6 + from ordereddict import OrderedDict + except ImportError as exc: + # Stub to throw errors at run-time (not import time) + def OrderedDict(*args, **kwargs): + raise RuntimeError( + "No OrderedDict implementation available; please " + "install the 'ordereddict' Package from PyPI.") + + def camel_case_to_pep8(name): """Convert a camel cased name to PEP8 style.""" converted = CAPITALS.sub(lambda m: '_' + m.groups()[0].lower(), name) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/happybase-0.7/happybase.egg-info/PKG-INFO new/happybase-0.8/happybase.egg-info/PKG-INFO --- old/happybase-0.7/happybase.egg-info/PKG-INFO 2013-11-06 23:20:22.000000000 +0100 +++ new/happybase-0.8/happybase.egg-info/PKG-INFO 2014-02-25 21:19:38.000000000 +0100 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: happybase -Version: 0.7 +Version: 0.8 Summary: A developer-friendly Python library to interact with Apache HBase Home-page: https://github.com/wbolster/happybase Author: Wouter Bolsterlee diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/happybase-0.7/tests/test_api.py new/happybase-0.8/tests/test_api.py --- old/happybase-0.7/tests/test_api.py 2013-11-06 22:46:27.000000000 +0100 +++ new/happybase-0.8/tests/test_api.py 2014-02-25 21:09:55.000000000 +0100 @@ -14,6 +14,7 @@ assert_in, assert_is_instance, assert_is_not_none, + assert_list_equal, assert_not_in, assert_raises, assert_true, @@ -23,7 +24,7 @@ HAPPYBASE_HOST = os.environ.get('HAPPYBASE_HOST') HAPPYBASE_PORT = os.environ.get('HAPPYBASE_PORT') -HAPPYBASE_COMPAT = os.environ.get('HAPPYBASE_COMPAT', '0.92') +HAPPYBASE_COMPAT = os.environ.get('HAPPYBASE_COMPAT', '0.96') HAPPYBASE_TRANSPORT = os.environ.get('HAPPYBASE_TRANSPORT', 'buffered') KEEP_TABLE = ('HAPPYBASE_NO_CLEANUP' in os.environ) @@ -273,7 +274,6 @@ exp = {'cf1:col1': 'v1new', 'cf1:col2': 'v2'} assert_dict_equal(exp, row(row_key, ['cf1'])) - assert_dict_equal(exp, row(row_key, ['cf1:'])) exp = {'cf1:col1': 'v1new', 'cf2:col2': 'v4'} @@ -428,6 +428,31 @@ next(scanner) +def test_scan_sorting(): + if connection.compat < '0.96': + return # not supported + + input_row = {} + for i in xrange(100): + input_row['cf1:col-%03d' % i] = '' + input_key = 'row-scan-sorted' + table.put(input_key, input_row) + + scan = table.scan(row_start=input_key, sorted_columns=True) + key, row = next(scan) + assert_equal(key, input_key) + assert_list_equal( + sorted(input_row.items()), + row.items()) + + +def test_scan_filter_and_batch_size(): + # See issue #54 and #56 + filter = "SingleColumnValueFilter ('cf1', 'qual1', =, 'binary:val1')" + for k, v in table.scan(filter=filter): + print v + + def test_delete(): row_key = 'row-test-delete' data = {'cf1:col1': 'v1', -- To unsubscribe, e-mail: opensuse-commit+unsubscr...@opensuse.org For additional commands, e-mail: opensuse-commit+h...@opensuse.org
