Make examples runnable under both python2 and python3.

Author: zhouzf05

examples/batch_get_row.py

@@ -4,21 +4,25 @@
 from tablestore import *
 import time
 
-table_name = 'OTSBatchGetRowSimpleExample'
+table_name_1 = 'OTSBatchGetRowSimpleExample_1'
+table_name_2 = 'OTSBatchGetRowSimpleExample_2'
 
-def create_table(client):
+def create_table(client, table_name):
     schema_of_primary_key = [('gid', 'INTEGER'), ('uid', 'INTEGER')]
     table_meta = TableMeta(table_name, schema_of_primary_key)
     table_option = TableOptions()
     reserved_throughput = ReservedThroughput(CapacityUnit(0, 0))
     client.create_table(table_meta, table_option, reserved_throughput)
     print ('Table has been created.')
 
-def delete_table(client):
-    client.delete_table(table_name)
-    print ('Table \'%s\' has been deleted.' % table_name)
+def delete_table(client, table_name):
+    try:
+        client.delete_table(table_name)
+        print ('Table \'%s\' has been deleted.' % table_name)
+    except:
+        pass
 
-def put_row(client):
+def put_row(client, table_name):
     for i in range(0, 10):
         primary_key = [('gid',i), ('uid',i+1)]
         attribute_columns = [('name','John'), ('mobile',i), ('address','China'), ('age',i)]
@@ -28,7 +32,7 @@ def put_row(client):
         print (u'Write succeed, consume %s write cu.' % consumed.write)
 
 def batch_get_row(client):
-    # try get 10 rows from exist table and 10 rows from not-exist table
+    # try to get rows from two different tables
     columns_to_get = ['name', 'mobile', 'address', 'age']
     rows_to_get = []
     for i in range(0, 10):
@@ -40,17 +44,17 @@ def batch_get_row(client):
     cond.add_sub_condition(SingleColumnCondition("address", 'China', ComparatorType.EQUAL))
 
     request = BatchGetRowRequest()
-    request.add(TableInBatchGetRowItem(table_name, rows_to_get, columns_to_get, cond, 1))
-    request.add(TableInBatchGetRowItem('notExistTable', rows_to_get, columns_to_get, cond, 1))
+    request.add(TableInBatchGetRowItem(table_name_1, rows_to_get, columns_to_get, cond, 1))
+    request.add(TableInBatchGetRowItem(table_name_2, rows_to_get, columns_to_get, cond, 1))
 
     result = client.batch_get_row(request)
 
     print ('Result status: %s'%(result.is_all_succeed()))
-    
-    table_result_0 = result.get_result_by_table(table_name)
-    table_result_1 = result.get_result_by_table('notExistTable')
 
-    print ('Check first table\'s result:')     
+    table_result_0 = result.get_result_by_table(table_name_1)
+    table_result_1 = result.get_result_by_table(table_name_2)
+
+    print ('Check first table\'s result:')
     for item in table_result_0:
         if item.is_ok:
             print ('Read succeed, PrimaryKey: %s, Attributes: %s' % (item.row.primary_key, item.row.attribute_columns))
@@ -66,15 +70,16 @@ def batch_get_row(client):
 
 if __name__ == '__main__':
     client = OTSClient(OTS_ENDPOINT, OTS_ID, OTS_SECRET, OTS_INSTANCE)
-    try:
-        delete_table(client)
-    except:
-        pass
+    delete_table(client, table_name_1)
+    delete_table(client, table_name_2)
 
-    create_table(client)
+    create_table(client, table_name_1)
+    create_table(client, table_name_2)
 
     time.sleep(3) # wait for table ready
-    put_row(client)
+    put_row(client, table_name_1)
+    put_row(client, table_name_2)
     batch_get_row(client)
-    delete_table(client)
+    delete_table(client, table_name_1)
+    delete_table(client, table_name_2)
 

examples/get_range.py

@@ -20,14 +20,14 @@ def delete_table(client):
 
 def put_row(client):
     for i in range(0, 100):
-        primary_key = [('uid',i), ('gid', bytearray(str(i+1)))]
+        primary_key = [('uid',i), ('gid', bytearray(str(i+1), 'utf-8'))]
         attribute_columns = [('name','John'), ('mobile',i), ('address','China'), ('age',i)]
         row = Row(primary_key, attribute_columns)
         condition = Condition(RowExistenceExpectation.IGNORE) # Expect not exist: put it into table only when this row is not exist.
         consumed, return_row = client.put_row(table_name, row, condition)
         print ('Write succeed, consume %s write cu.' % consumed.write)
 
-def get_range(client): 
+def get_range(client):
     '''
         Scan table to get all the rows.
         It will not return you all once, you should continue read from next start primary key till next start primary key is None.
@@ -42,10 +42,10 @@ def get_range(client):
     cond.add_sub_condition(SingleColumnCondition("age", 50, ComparatorType.LESS_THAN))
 
     consumed, next_start_primary_key, row_list, next_token  = client.get_range(
-                table_name, Direction.FORWARD, 
+                table_name, Direction.FORWARD,
                 inclusive_start_primary_key, exclusive_end_primary_key,
-                columns_to_get, 
-                limit, 
+                columns_to_get,
+                limit,
                 column_filter = cond,
                 max_version = 1
     )
@@ -55,9 +55,9 @@ def get_range(client):
     while next_start_primary_key is not None:
         inclusive_start_primary_key = next_start_primary_key
         consumed, next_start_primary_key, row_list, next_token = client.get_range(
-                table_name, Direction.FORWARD, 
+                table_name, Direction.FORWARD,
                 inclusive_start_primary_key, exclusive_end_primary_key,
-                columns_to_get, limit, 
+                columns_to_get, limit,
                 column_filter = cond,
                 max_version = 1
         )
@@ -79,10 +79,10 @@ def xget_range(client):
     cond = CompositeColumnCondition(LogicalOperator.AND)
     cond.add_sub_condition(SingleColumnCondition("address", 'China', ComparatorType.EQUAL))
     cond.add_sub_condition(SingleColumnCondition("age", 50, ComparatorType.GREATER_EQUAL))
-     
+
     columns_to_get = []
     range_iter = client.xget_range(
-                table_name, Direction.FORWARD, 
+                table_name, Direction.FORWARD,
                 inclusive_start_primary_key, exclusive_end_primary_key,
                 consumed_counter, columns_to_get, 100,
                 column_filter = cond, max_version = 1

examples/put_row.py

@@ -23,7 +23,7 @@ def delete_table(client):
 
 def put_row(client):
     primary_key = [('gid',1), ('uid',101)]
-    attribute_columns = [('name','萧峰'), ('mobile',15100000000), ('address', bytearray('China')), 
+    attribute_columns = [('name','萧峰'), ('mobile',15100000000), ('address', bytearray('China', 'utf-8')),
                          ('female', False), ('age', 29.7)]
     row = Row(primary_key, attribute_columns)
 

examples/search_index.py

@@ -23,16 +23,16 @@ def match_all_query(table_name, index_name):
         all_rows.extend(rows)
 
     for row in all_rows:
-        print row
+        print(row)
 
-    print 'Total rows:', len(all_rows)
+    print ('Total rows: %d' % len(all_rows))
 
 def _print_rows(rows, total_count):
     for row in rows:
-        print row
+        print(row)
 
-    print 'Rows return:', len(rows)
-    print 'Total count:', total_count
+    print ('Rows return: %d' % len(rows))
+    print ('Total count: %d' % total_count)
 
 def match_query(table_name, index_name):
     query = MatchQuery('t', 'this is 0')
@@ -122,7 +122,7 @@ def bool_query(table_name, index_name):
 def geo_distance_query(table_name, index_name):
     query = GeoDistanceQuery('g', '32.5,116.5', 300000)
     sort = Sort(sorters=[
-            GeoDistanceSort('g', ['32.5,116.5', '32.0,116.0'], sort_order=SortOrder.DESC, sort_mode=SortMode.MAX)
+            GeoDistanceSort('g', ['32.5,116.5', '32.0,116.0'], sort_order=SortOrder.DESC)
         ])
     rows, next_token, total_count, is_all_succeed = client.search(
         table_name, index_name, SearchQuery(query, limit=100, get_total_count=True, sort=sort), ColumnsToGet(return_type=ColumnReturnType.ALL)
@@ -171,6 +171,7 @@ def function_score_query(table_name, index_name):
     _print_rows(rows, total_count)
 
 def prepare_data(rows_count):
+    print ('Begin prepare data: %d' % rows_count)
     for i in range(rows_count):
         pk = [('PK1', i), ('PK2', 'pk_' + str(i % 10))]
         lj = i / 100
@@ -183,6 +184,8 @@ def prepare_data(rows_count):
 
         client.put_row(table_name, Row(pk, cols))
 
+    print ('End prepare data.')
+
 def prepare_table():
     table_meta = TableMeta(table_name, [('PK1', 'INTEGER'), ('PK2', 'STRING')])
 
@@ -216,52 +219,64 @@ def prepare_index(index_name, with_nested=False):
 
 def list_search_index():
     for table, index_name in client.list_search_index(table_name):
-        print table, index_name
+        print ('%s, %s' % (table, index_name))
 
 def describe_search_index():
     index_meta, sync_stat = client.describe_search_index(table_name, index_name)
-    print json.dumps(index_meta, default=lambda x:x.__dict__, indent=2)
-    print json.dumps(sync_stat, default=lambda x:x.__dict__, indent=2)
+    print ('sync stat: %s, %d' % (str(sync_stat.sync_phase), sync_stat.current_sync_timestamp))
+    print ('index name: %s' % index_name)
+    print ('index fields:')
+    for field in index_meta.fields:
+        print ('  field name: %s' % field.field_name)
+        print ('  field type: %s' % str(field.field_type))
+        print ('  field indexed: %s' % str(field.index))
+        print ('  field stored: %s' % str(field.store))
+        print ('  field is array: %s' % str(field.is_array))
+        print ('  field allow sort and aggregate: %s' % str(field.enable_sort_and_agg))
+    print ('index routing keys: %s' % str(index_meta.index_setting.routing_fields))
+    print ('index sort: %s' % (index_meta.index_sort.sorters))
 
 def delete_table():
     try:
         client.delete_table(table_name)
-    except Exception,e:
-        print e
+    except:
+        pass
 
 def delete_search_index(index_name):
     try:
         client.delete_search_index(table_name, index_name)
-    except Exception,e:
-        print e
+    except:
+        pass
 
 if __name__ == '__main__':
     client = OTSClient(OTS_ENDPOINT, OTS_ID, OTS_SECRET, OTS_INSTANCE)
-    #delete_search_index(index_name)
-    #delete_search_index(nested_index_name)
-    #delete_table()
-
-    #prepare_table()
-    #prepare_index(index_name, with_nested=False)
-    #prepare_index(nested_index_name, with_nested=True)
-    #prepare_data(1000)
+    delete_search_index(index_name)
+    delete_search_index(nested_index_name)
+    delete_table()
 
-    #list_search_index()
-    #describe_search_index()
+    prepare_table()
+    prepare_index(index_name, with_nested=False)
+    prepare_index(nested_index_name, with_nested=True)
+    prepare_data(1000)
+    list_search_index()
+    describe_search_index()
 
     # perform queries
-    #match_all_query(table_name, index_name)
+    match_all_query(table_name, index_name)
     match_query(table_name, index_name)
-    #match_phrase_query(table_name, index_name)
-    #term_query(table_name, index_name)
-    #range_query(table_name, index_name)
-    #prefix_query(table_name, index_name)
-    #terms_query(table_name, index_name)
-    #bool_query(table_name, index_name)
-    #wildcard_query(table_name, index_name)
-    #geo_distance_query(table_name, index_name)
-    #geo_bounding_box_query(table_name, index_name)
-    #geo_polygon_query(table_name, index_name)
-    #nested_query(table_name, nested_index_name)
-    #function_score_query(table_name, nested_index_name)
-
+    match_phrase_query(table_name, index_name)
+    term_query(table_name, index_name)
+    range_query(table_name, index_name)
+    prefix_query(table_name, index_name)
+    terms_query(table_name, index_name)
+    bool_query(table_name, index_name)
+    wildcard_query(table_name, index_name)
+    geo_distance_query(table_name, index_name)
+    geo_bounding_box_query(table_name, index_name)
+    geo_polygon_query(table_name, index_name)
+    nested_query(table_name, nested_index_name)
+    function_score_query(table_name, nested_index_name)
+
+    delete_search_index(index_name)
+    delete_search_index(nested_index_name)
+    delete_table()

examples/secondary_index_operations.py

@@ -6,6 +6,8 @@
 import json
 
 table_name = 'SecondaryIndexOperationExample'
+index_name_1 = 'index1'
+index_name_2 = 'index2'
 
 def create_table(client):
     print ('Begin CreateTable')
@@ -15,14 +17,14 @@ def create_table(client):
     table_option = TableOptions(-1, 1)
     reserved_throughput = ReservedThroughput(CapacityUnit(0, 0))
     secondary_indexes = [
-            SecondaryIndexMeta('index1', ['i', 's'], ['gid', 'uid', 'bool', 'b', 'd']),
+            SecondaryIndexMeta(index_name_1, ['i', 's'], ['bool', 'b', 'd']),
             ]
     client.create_table(table_meta, table_option, reserved_throughput, secondary_indexes)
     print ('Table has been created.')
 
 def create_index(client):
     print ('Begin CreateIndex')
-    index_meta = SecondaryIndexMeta('index2', ['i', 's'], ['gid', 'uid', 'bool', 'b', 'd'])
+    index_meta = SecondaryIndexMeta(index_name_2, ['i', 's'], ['bool', 'b', 'd'])
     client.create_secondary_index(table_name, index_meta)
     print ('Index has been created.')
 
@@ -40,12 +42,14 @@ def describe_table(client):
     print ('table options\'s max_time_deviation: %s' % describe_response.table_options.max_time_deviation)
     print ('Secondary indexes:')
     for secondary_index in describe_response.secondary_indexes:
-        print (json.dumps(secondary_index, default=lambda x:x.__dict__, indent=2))
+        print ('index name: %s' % secondary_index.index_name)
+        print ('primary key names: %s' % str(secondary_index.primary_key_names))
+        print ('defined column names: %s' % str(secondary_index.defined_column_names))
     print ('End DescribeTable')
 
-def delete_index(client):
+def delete_index(client, index_name):
     print ('Begin DeleteIndex')
-    client.delete_secondary_index(table_name, 'index1')
+    client.delete_secondary_index(table_name, index_name)
     print ('End delete index.')
 
 def delete_table(client):
@@ -57,7 +61,6 @@ def delete_table(client):
     client = OTSClient(OTS_ENDPOINT, OTS_ID, OTS_SECRET, OTS_INSTANCE)
     try:
         delete_table(client)
-        print 'delete succeeded.'
     except:
         pass
 
@@ -66,6 +69,8 @@ def delete_table(client):
     #time.sleep(3) # wait for table ready
     create_index(client)
     describe_table(client)
-    delete_index(client)
+    delete_index(client, index_name_1)
     describe_table(client)
+    delete_index(client, index_name_2)
+    delete_table(client)
 

examples/table_operations.py

@@ -36,7 +36,7 @@ def describe_table(client):
     print ('table options\'s max version: %s' % describe_response.table_options.max_version)
     print ('table options\'s max_time_deviation: %s' % describe_response.table_options.max_time_deviation)
     print ('End DescribeTable')
-        
+
 def update_table(client):
     print ('Begin UpdateTable')
     table_option = TableOptions(100001, None, None)
@@ -59,7 +59,6 @@ def delete_table(client):
     client = OTSClient(OTS_ENDPOINT, OTS_ID, OTS_SECRET, OTS_INSTANCE)
     try:
         delete_table(client)
-        print 'delete succeeded.'
     except:
         pass
 

examples/update_row.py

@@ -50,20 +50,18 @@ def get_row(client):
 
 if __name__ == '__main__':
     client = OTSClient(OTS_ENDPOINT, OTS_ID, OTS_SECRET, OTS_INSTANCE)
-    '''
     try:
         delete_table(client)
     except:
         pass
     create_table(client)
-    '''
 
     #time.sleep(3) # wait for table ready
-    #put_row(client)
+    put_row(client)
     print ('#### row before update ####')
     get_row(client)
     update_row(client)
     print ('#### row after update ####')
     get_row(client)
-    #delete_table(client)
+    delete_table(client)