Evaluate the schema when requesting tables (#24)

Author: andresmgot

completion.go

@@ -11,8 +11,8 @@ import (
 
 // Completable will be used to autocomplete Tables Schemas and Columns for SQL languages
 type Completable interface {
-	Tables(ctx context.Context) ([]string, error)
 	Schemas(ctx context.Context) ([]string, error)
+	Tables(ctx context.Context, schema string) ([]string, error)
 	Columns(ctx context.Context, table string) ([]string, error)
 }
 
@@ -32,17 +32,21 @@ func sendResourceResponse(rw http.ResponseWriter, res []string) {
 	}
 }
 
+type tableRequest struct {
+	Schema string `json:"schema"`
+}
+
 type columnRequest struct {
 	Table string `json:"table"`
 }
 
-func (ds *sqldatasource) getTables(rw http.ResponseWriter, req *http.Request) {
+func (ds *sqldatasource) getSchemas(rw http.ResponseWriter, req *http.Request) {
 	if ds.Completable == nil {
 		handleError(rw, errors.New("not implemented"))
 		return
 	}
 
-	res, err := ds.Completable.Tables(req.Context())
+	res, err := ds.Completable.Schemas(req.Context())
 	if err != nil {
 		handleError(rw, err)
 		return
@@ -51,13 +55,18 @@ func (ds *sqldatasource) getTables(rw http.ResponseWriter, req *http.Request) {
 	sendResourceResponse(rw, res)
 }
 
-func (ds *sqldatasource) getSchemas(rw http.ResponseWriter, req *http.Request) {
+func (ds *sqldatasource) getTables(rw http.ResponseWriter, req *http.Request) {
 	if ds.Completable == nil {
 		handleError(rw, errors.New("not implemented"))
 		return
 	}
 
-	res, err := ds.Completable.Schemas(req.Context())
+	reqBody := tableRequest{}
+	if err := json.NewDecoder(req.Body).Decode(&reqBody); err != nil {
+		handleError(rw, err)
+		return
+	}
+	res, err := ds.Completable.Tables(req.Context(), reqBody.Schema)
 	if err != nil {
 		handleError(rw, err)
 		return

completion_test.go

@@ -50,19 +50,20 @@ func Test_sendResourceResponse(t *testing.T) {
 }
 
 type fakeCompletable struct {
-	tables  []string
 	schemas []string
+	tables  map[string][]string
 	columns map[string][]string
 	err     error
 }
 
-func (f *fakeCompletable) Tables(ctx context.Context) ([]string, error) {
-	return f.tables, f.err
-}
 func (f *fakeCompletable) Schemas(ctx context.Context) ([]string, error) {
 	return f.schemas, f.err
+}
 
+func (f *fakeCompletable) Tables(ctx context.Context, schema string) ([]string, error) {
+	return f.tables[schema], f.err
 }
+
 func (f *fakeCompletable) Columns(ctx context.Context, table string) ([]string, error) {
 	return f.columns[table], f.err
 }
@@ -75,20 +76,20 @@ func TestCompletable(t *testing.T) {
 		reqBody     string
 		expectedRes string
 	}{
-		{
-			"it should return tables",
-			"tables",
-			&fakeCompletable{tables: []string{"foo", "bar"}},
-			"",
-			`["foo","bar"]` + "\n",
-		},
 		{
 			"it should return schemas",
 			"schemas",
 			&fakeCompletable{schemas: []string{"foo", "bar"}},
 			"",
 			`["foo","bar"]` + "\n",
 		},
+		{
+			"it should return tables of a schema",
+			"tables",
+			&fakeCompletable{tables: map[string][]string{"foobar": {"foo", "bar"}}},
+			`{"schema":"foobar"}`,
+			`["foo","bar"]` + "\n",
+		},
 		{
 			"it should return columns of a table",
 			"columns",
@@ -104,13 +105,15 @@ func TestCompletable(t *testing.T) {
 			sqlds := &sqldatasource{}
 			sqlds.Completable = test.fakeImpl
 
+			b := ioutil.NopCloser(bytes.NewReader([]byte(test.reqBody)))
 			switch test.method {
-			case "tables":
-				sqlds.getTables(w, &http.Request{})
 			case "schemas":
 				sqlds.getSchemas(w, &http.Request{})
+			case "tables":
+				sqlds.getTables(w, &http.Request{
+					Body: b,
+				})
 			case "columns":
-				b := ioutil.NopCloser(bytes.NewReader([]byte(test.reqBody)))
 				sqlds.getColumns(w, &http.Request{
 					Body: b,
 				})