Support for namespaces in requests (on-premise only) (#20)

On-premise only: added support for default namespace in config and
namespace in requests.

Author: connelly38

CHANGELOG.md

@@ -12,6 +12,8 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
   with Instance Principals:
      * NewSignatureProviderWithInstancePrincipalDelegation
      * NewSignatureProviderWithInstancePrincipalDelegationFromFile
+- On-premise only: added support for default namespace in config and
+  namespace in requests.
 
 ### Changed
 - Updated yaml.v2 to 2.4.0

internal/test/nosql_testsuite.go

@@ -143,7 +143,7 @@ func (suite *NoSQLTestSuite) GetNsTableName(ns, table string) string {
 }
 
 // DropTable drops the table.
-func (suite *NoSQLTestSuite) DropTable(table string, dropIfExists bool) {
+func (suite *NoSQLTestSuite) DropTableWithNamespace(table string, dropIfExists bool, namespace string) {
 	var stmt string
 	if dropIfExists {
 		stmt = "DROP TABLE IF EXISTS " + table
@@ -153,36 +153,61 @@ func (suite *NoSQLTestSuite) DropTable(table string, dropIfExists bool) {
 
 	req := &nosqldb.TableRequest{
 		Statement: stmt,
+		Namespace: namespace,
 	}
 
 	// BUG(zehliu): DoTableRequestAndWait does not seem to work for MiniCloud.
 	_, err := suite.Client.DoTableRequestAndWait(req, 30*time.Second, time.Second)
 	suite.Require().NoErrorf(err, "%q: got error %v.", stmt, err)
 }
 
+// DropTable drops the table.
+func (suite *NoSQLTestSuite) DropTable(table string, dropIfExists bool) {
+	suite.DropTableWithNamespace(table, dropIfExists, "")
+}
+
 // ExecuteDDL executes the specified DDL statement using a SystemRequest.
 func (suite *NoSQLTestSuite) ExecuteDDL(stmt string) {
 	_, err := suite.Client.DoSystemRequestAndWait(stmt, 30*time.Second, time.Second)
 	suite.Require().NoErrorf(err, "failed to execute %q, got error %v.", stmt, err)
 }
 
 // ExecuteTableDDL executes the specified DDL statement using a TableRequest.
-func (suite *NoSQLTestSuite) ExecuteTableDDL(stmt string) {
-	req := &nosqldb.TableRequest{Statement: stmt}
+func (suite *NoSQLTestSuite) ExecuteTableDDLWithNamespace(stmt string, namespace string) {
+	req := &nosqldb.TableRequest{Statement: stmt, Namespace: namespace}
 	_, err := suite.Client.DoTableRequestAndWait(req, 30*time.Second, time.Second)
 	suite.Require().NoErrorf(err, "failed to execute %q, got error %v.", stmt, err)
 }
 
+func (suite *NoSQLTestSuite) ExecuteTableDDL(stmt string) {
+	suite.ExecuteTableDDLWithNamespace(stmt, "")
+}
+
 // ExecuteQueryStmt executes the query statement.
 func (suite *NoSQLTestSuite) ExecuteQueryStmt(stmt string) ([]*types.MapValue, error) {
 	return suite.ExecuteQueryRequest(&nosqldb.QueryRequest{Statement: stmt})
 }
 
+// ExecuteQueryStmtWithNamespace executes the query statement in given namespace
+func (suite *NoSQLTestSuite) ExecuteQueryStmtWithNamespace(stmt string, namespace string) ([]*types.MapValue, error) {
+	return suite.ExecuteQueryRequest(&nosqldb.QueryRequest{Statement: stmt, Namespace: namespace})
+}
+
 // ExecuteQueryRequest executes the query request.
 func (suite *NoSQLTestSuite) ExecuteQueryRequest(queryReq *nosqldb.QueryRequest) ([]*types.MapValue, error) {
 	return ExecuteQueryRequest(suite.Client, queryReq)
 }
 
+// DoQueryWithNamespace executes the query statement in given namespace and
+// expects a given number of rows returned
+func (suite *NoSQLTestSuite) DoQueryWithNamespace(stmt string, namespace string, expRows int) {
+	res, err := suite.ExecuteQueryRequest(&nosqldb.QueryRequest{Statement: stmt, Namespace: namespace})
+	if suite.NoErrorf(err, "Unexpected error running query: %v", err) {
+		suite.Equalf(expRows, len(res), "wrong number of rows returned from query")
+	}
+}
+
+// ExecuteQueryRequest executes the query request.
 // AddToTables adds the specified table into a table list, in which all tables
 // would be dropped on TearDownSuite if DropTablesOnTearDown is specified in test configuration.
 func (suite *NoSQLTestSuite) AddToTables(table string) {

nosqldb/client.go

@@ -1052,6 +1052,10 @@ func (c *Client) doExecute(ctx context.Context, req Request, data []byte, serial
 		httpReq.Header.Set("Accept", "application/octet-stream")
 		httpReq.Header.Set("Connection", "keep-alive")
 		httpReq.Header.Set("User-Agent", sdkutil.UserAgent())
+		namespace := req.getNamespace()
+		if namespace != "" {
+			httpReq.Header.Add("x-nosql-default-ns", namespace)
+		}
 
 		// The authorization string could be empty when the client connects to a
 		// non-secure on-premise NoSQL database server over database proxy.

nosqldb/config.go

@@ -98,7 +98,7 @@ type Config struct {
 	// This is only used for on-premise NoSQL server that configured with security.
 	Password []byte `json:"password,omitempty"`
 
-	// Configurations for requests.
+	// Default Configurations for requests.
 	RequestConfig `json:"requestConfig,omitempty"`
 
 	// Configurations for HTTP client.
@@ -408,6 +408,13 @@ type RequestConfig struct {
 	// include GetRequest and QueryRequest.
 	// If set, it must be either types.Eventual or types.Absolute.
 	Consistency types.Consistency `json:"consistency,omitempty"`
+
+	// Namespace is used on-premises only. It defines a namespace to use
+	// for the request if it is not specified in the request struct itself or
+	// in an SQL DDL/Query using the 'namespace:tablename' format.
+	// This is only available with on-premises installations using NoSQL
+	// Server versions 23.3 and above.
+	Namespace string `json:"namespace,omitempty"`
 }
 
 // DefaultRequestTimeout returns the default timeout value for requests.
@@ -451,6 +458,18 @@ func (r *RequestConfig) DefaultConsistency() types.Consistency {
 	return r.Consistency
 }
 
+// DefaultNamespace is used on-premises only. It defines a namespace to use
+// for the request if it is not specified in the request struct itself or
+// in an SQL DDL/Query using the 'namespace:tablename' format.
+// This is only available with on-premises installations using NoSQL
+// Server versions 23.3 and above.
+func (r *RequestConfig) DefaultNamespace() string {
+	if r == nil {
+		return ""
+	}
+	return r.Namespace
+}
+
 // LoggingConfig represents logging configurations.
 type LoggingConfig struct {
 

nosqldb/onprem_ops_test.go

@@ -86,6 +86,144 @@ func (suite *OnPremTestSuite) TestNamespacesOp() {
 	suite.doDDLTest("drop namespace NSABC", nosqlerr.NoError)
 }
 
+// TestNamespacesOp tests create, drop and show namespaces operations.
+func (suite *OnPremTestSuite) TestDefaultNamespaces() {
+
+	// this only works with versions of KV with default namespace support
+	if suite.Config.Version <= "22.3.31" {
+		return
+	}
+
+	suite.Client.RequestConfig.Namespace = "mydns"
+	suite.doDDLTest("create namespace mydns", nosqlerr.NoError)
+
+	// parent in mydns
+	stmt := "create table parent(sid integer, id integer, name string, " +
+			"salary long, primary key(SHARD(sid), id))"
+	suite.CreateTable(stmt, nil)
+
+	// child in mydns
+	stmt = "create table parent.child(cid integer, cname string, " +
+			"primary key(cid))"
+	suite.CreateTable(stmt, nil)
+
+	// test ListTables with default namespace: should return just myns
+	req := &nosqldb.ListTablesRequest{}
+	res, err := suite.Client.ListTables(req)
+	if suite.NoErrorf(err, "ListTables failed: %v", err) {
+		suite.Equalf(2, len(res.Tables), "unexpected number of tables returned")
+	}
+
+	// test ListTables with explicit namespace
+	req = &nosqldb.ListTablesRequest{Namespace: "mydns"}
+	res, err = suite.Client.ListTables(req)
+	if suite.NoErrorf(err, "ListTables failed: %v", err) {
+		suite.Equalf(2, len(res.Tables), "unexpected number of tables returned")
+	}
+
+	// test ListTables with explicit invalid
+	req = &nosqldb.ListTablesRequest{Namespace: "invalid"}
+	res, err = suite.Client.ListTables(req)
+	if suite.NoErrorf(err, "ListTables failed: %v", err) {
+		suite.Equalf(0, len(res.Tables), "expected zero tables returned for invalid namespace")
+	}
+
+	suite.Client.RequestConfig.Namespace = ""
+
+	// test ListTables with no namespace: should return all
+	req = &nosqldb.ListTablesRequest{}
+	res, err = suite.Client.ListTables(req)
+	if suite.NoErrorf(err, "ListTables failed: %v", err) {
+		// should have more than 2 tables listed
+		if len(res.Tables) <= 2 {
+			suite.Fail("Expected more than 2 tables, got %d", len(res.Tables))
+		}
+	}
+
+	suite.Client.RequestConfig.Namespace = "mydns"
+
+	// put data in both tables
+	for i:=0; i<10; i++ {
+		value := &types.MapValue{}
+		value.Put("id", i).Put("name", "pname")
+		value.Put("sid", i).Put("salary", i*1000)
+		putReq := &nosqldb.PutRequest{
+			TableName: "parent",
+			Value:     value,
+		}
+		//putRes, err := suite.Client.Put(putReq)
+		_, err := suite.Client.Put(putReq)
+		suite.NoErrorf(err, "Parent put failed: %v", err)
+		for j:=0; j<10; j++ {
+			value.Put("cid", j).Put("cname", fmt.Sprintf("cname%d", j))
+			putReq.TableName = "parent.child"
+			putReq.Value = value
+			//putRes, err = suite.Client.Put(putReq)
+			_, err = suite.Client.Put(putReq)
+			suite.NoErrorf(err, "Child put failed: %v", err)
+		}
+	}
+
+	// get parent
+	key := types.ToMapValue("id", 1).Put("sid", 1)
+	getReq := &nosqldb.GetRequest{TableName: "parent", Key: key}
+	_, err = suite.Client.Get(getReq)
+	suite.NoErrorf(err, "Error trying to get record from parent: %v", err)
+
+	// get child
+	key = types.ToMapValue("id", 1).Put("sid", 1).Put("cid", 1)
+	getReq = &nosqldb.GetRequest{TableName: "parent.child", Key: key}
+	_, err = suite.Client.Get(getReq)
+	suite.NoErrorf(err, "Error trying to get record from child: %v", err)
+
+	// same ops should fail with no default namespace
+	suite.Client.RequestConfig.Namespace = ""
+	// get parent
+	key = types.ToMapValue("id", 1).Put("sid", 1)
+	getReq = &nosqldb.GetRequest{TableName: "parent", Key: key}
+	_, err = suite.Client.Get(getReq)
+	suite.Errorf(err, "Expected error trying to get record from parent, got none")
+
+	// get child
+	key = types.ToMapValue("id", 1).Put("sid", 1).Put("cid", 1)
+	getReq = &nosqldb.GetRequest{TableName: "parent.child", Key: key}
+	_, err = suite.Client.Get(getReq)
+	suite.Errorf(err, "Expected error trying to get record from child, got none")
+
+	// verify namespace in tablename overrides default
+	key = types.ToMapValue("id", 1).Put("sid", 1).Put("cid", 1)
+	getReq = &nosqldb.GetRequest{TableName: "mydns:parent.child", Key: key, Namespace: "invalid"}
+	_, err = suite.Client.Get(getReq)
+	suite.NoErrorf(err, "Error trying to get record from child: %v", err)
+
+
+	// query parent
+	stmt = "select * from parent"
+	suite.Client.RequestConfig.Namespace = "mydns"
+	suite.DoQueryWithNamespace(stmt, "", 10)
+	suite.Client.RequestConfig.Namespace = "invalid"
+	suite.DoQueryWithNamespace(stmt, "mydns", 10)
+
+	// query child
+	stmt = "select * from parent.child"
+	suite.Client.RequestConfig.Namespace = "mydns"
+	suite.DoQueryWithNamespace(stmt, "", 100)
+	suite.Client.RequestConfig.Namespace = "invalid"
+	suite.DoQueryWithNamespace(stmt, "mydns", 100)
+
+	// test complex query (exercises internal request copying)
+	suite.Client.RequestConfig.Namespace = ""
+	stmt = "select sid, count(*) as cnt, sum(salary) as sum " +
+			"from parent group by sid";
+	suite.DoQueryWithNamespace(stmt, "mydns", 10)
+
+	// drop table with namespace in request
+	suite.DropTableWithNamespace("parent.child", false, "mydns")
+
+	// drop namespace - use cascade to remove tables
+	suite.doDDLTest("drop namespace mydns cascade", nosqlerr.NoError)
+}
+
 // TestUserRolesOp tests create/drop/show/list users, create/drop/show/list roles
 // and grant/revoke roles operations.
 //