Merge remote-tracking branch 'upstream/master' into itn/tables-quotes-2

# Conflicts:
#	pkg/client/client.go

.travis.yml

@@ -14,10 +14,7 @@ go:
   - 1.7.6
   - 1.8.7
   - 1.9.3
-  - 1.10.0
-
-env:
-  - GO15VENDOREXPERIMENT=1
+  - 1.10.1
 
 before_install:
   - ./script/check_formatting.sh

CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.9.12 - 2018-04-23
+
+- Add link to view database connection string format on login page
+- Include constraint name under "constraints" tab, GH-343
+- Misc CI and config changes
+
 ## 0.9.11 - 2017-12-07
 
 - Fix ssl mode for the connection url in the bookmarks, GH-320

Dockerfile

@@ -1,11 +1,9 @@
 FROM alpine:3.6
-MAINTAINER Dan Sosedoff <dan.sosedoff@gmail.com>
-
-ENV PGWEB_VERSION 0.9.11
+LABEL maintainer="Dan Sosedoff <dan.sosedoff@gmail.com>"
+ENV PGWEB_VERSION 0.9.12
 
 RUN \
-  apk update && \
-  apk add --update ca-certificates openssl && \
+  apk add --no-cache ca-certificates openssl postgresql && \
   update-ca-certificates && \
   cd /tmp && \
   wget https://github.com/sosedoff/pgweb/releases/download/v$PGWEB_VERSION/pgweb_linux_amd64.zip && \
@@ -14,4 +12,4 @@ RUN \
   rm -f pgweb_linux_amd64.zip
 
 EXPOSE 8081
-CMD ["/usr/bin/pgweb", "--bind=0.0.0.0", "--listen=8081"]
+CMD ["/usr/bin/pgweb", "--bind=0.0.0.0", "--listen=8081"]

Makefile

@@ -25,10 +25,11 @@ usage:
 	@echo ""
 
 test:
-	go test -cover ./pkg/...
+	go test -race -cover ./pkg/...
 
 test-all:
 	@./script/test_all.sh
+	@./script/test_cockroach.sh
 
 assets: static/
 	go-bindata -o pkg/data/bindata.go -pkg data $(BINDATA_OPTS) $(BINDATA_IGNORE) -ignore=[.]gitignore -ignore=[.]gitkeep $<...
@@ -63,10 +64,10 @@ bootstrap:
 	gox -build-toolchain
 
 setup:
-	go get github.com/tools/godep
-	go get golang.org/x/tools/cmd/cover
-	go get github.com/mitchellh/gox
-	go get github.com/jteeuwen/go-bindata/...
+	go get -u github.com/tools/godep
+	go get -u golang.org/x/tools/cmd/cover
+	go get -u github.com/mitchellh/gox
+	go get -u github.com/jteeuwen/go-bindata/...
 	godep restore
 
 clean:

data/roach.sql

@@ -0,0 +1,43 @@
+DROP DATABASE IF EXISTS "roach";
+CREATE DATABASE "roach";
+USE "roach";
+
+CREATE TABLE product_information (
+  product_id           INT PRIMARY KEY NOT NULL,
+  product_name         STRING(50) UNIQUE NOT NULL,
+  product_description  STRING(2000),
+  category_id          STRING(1) NOT NULL CHECK (category_id IN ('A','B','C')),
+  weight_class         INT,
+  warranty_period      INT CONSTRAINT valid_warranty CHECK (warranty_period BETWEEN 0 AND 24),
+  supplier_id          INT,
+  product_status       STRING(20),
+  list_price           DECIMAL(8,2),
+  min_price            DECIMAL(8,2),
+  catalog_url          STRING(50) UNIQUE,
+  date_added           DATE DEFAULT CURRENT_DATE(),
+  misc                 JSONB,     
+  CONSTRAINT price_check CHECK (list_price >= min_price),
+  INDEX date_added_idx (date_added),
+  INDEX supp_id_prod_status_idx (supplier_id, product_status),
+  INVERTED INDEX details (misc)
+);
+
+INSERT INTO product_information VALUES
+  (1, 'Product A', 'Text', 'A', NULL, 1),
+  (2, 'Product B', 'Text', 'B', NULL, 2),
+  (3, 'Product C', 'Text', 'C', NULL, 3);
+
+CREATE TABLE customers (
+  id INT PRIMARY KEY,
+  name STRING
+);
+
+CREATE TABLE orders (
+  id INT PRIMARY KEY,
+  customer_id INT REFERENCES customers(id) ON DELETE CASCADE
+);
+
+INSERT INTO customers VALUES (1, 'Lauren');
+INSERT INTO orders VALUES (1,1);
+DELETE FROM customers WHERE id = 1;
+SELECT * FROM orders;

pkg/api/api.go

@@ -472,6 +472,13 @@ func DataExport(c *gin.Context) {
 		Table: strings.TrimSpace(c.Request.FormValue("table")),
 	}
 
+	// If pg_dump is not available the following code will not show an error in browser.
+	// This is due to the headers being written first.
+	if !dump.CanExport() {
+		c.JSON(400, Error{"pg_dump is not found"})
+		return
+	}
+
 	formattedInfo := info.Format()[0]
 	filename := formattedInfo["current_database"].(string)
 	if dump.Table != "" {

pkg/api/routes.go

@@ -18,41 +18,38 @@ func SetupMiddlewares(group *gin.RouterGroup) {
 }
 
 func SetupRoutes(router *gin.Engine) {
-	group := router.Group(command.Opts.Prefix)
-
-	group.GET("/", GetHome)
-	group.GET("/static/*path", GetAsset)
-
-	api := group.Group("/api")
-	{
-		SetupMiddlewares(api)
-
-		if command.Opts.Sessions {
-			api.GET("/sessions", GetSessions)
-		}
-
-		api.GET("/info", GetInfo)
-		api.POST("/connect", Connect)
-		api.POST("/disconnect", Disconnect)
-		api.POST("/switchdb", SwitchDb)
-		api.GET("/databases", GetDatabases)
-		api.GET("/connection", GetConnectionInfo)
-		api.GET("/activity", GetActivity)
-		api.GET("/schemas", GetSchemas)
-		api.GET("/objects", GetObjects)
-		api.GET("/tables/:table", GetTable)
-		api.GET("/tables/:table/rows", GetTableRows)
-		api.GET("/tables/:table/info", GetTableInfo)
-		api.GET("/tables/:table/indexes", GetTableIndexes)
-		api.GET("/tables/:table/constraints", GetTableConstraints)
-		api.GET("/query", RunQuery)
-		api.POST("/query", RunQuery)
-		api.GET("/explain", ExplainQuery)
-		api.POST("/explain", ExplainQuery)
-		api.GET("/history", GetHistory)
-		api.GET("/bookmarks", GetBookmarks)
-		api.GET("/export", DataExport)
+	root := router.Group(command.Opts.Prefix)
+
+	root.GET("/", GetHome)
+	root.GET("/static/*path", GetAsset)
+	root.GET("/connect/:resource", ConnectWithBackend)
+
+	api := root.Group("/api")
+	SetupMiddlewares(api)
+
+	if command.Opts.Sessions {
+		api.GET("/sessions", GetSessions)
 	}
 
-	group.GET("/connect/:resource", ConnectWithBackend)
+	api.GET("/info", GetInfo)
+	api.POST("/connect", Connect)
+	api.POST("/disconnect", Disconnect)
+	api.POST("/switchdb", SwitchDb)
+	api.GET("/databases", GetDatabases)
+	api.GET("/connection", GetConnectionInfo)
+	api.GET("/activity", GetActivity)
+	api.GET("/schemas", GetSchemas)
+	api.GET("/objects", GetObjects)
+	api.GET("/tables/:table", GetTable)
+	api.GET("/tables/:table/rows", GetTableRows)
+	api.GET("/tables/:table/info", GetTableInfo)
+	api.GET("/tables/:table/indexes", GetTableIndexes)
+	api.GET("/tables/:table/constraints", GetTableConstraints)
+	api.GET("/query", RunQuery)
+	api.POST("/query", RunQuery)
+	api.GET("/explain", ExplainQuery)
+	api.POST("/explain", ExplainQuery)
+	api.GET("/history", GetHistory)
+	api.GET("/bookmarks", GetBookmarks)
+	api.GET("/export", DataExport)
 }

pkg/cli/cli.go

@@ -81,7 +81,7 @@ func initClient() {
 	}
 
 	if !command.Opts.Sessions {
-		fmt.Printf("Server runs PostgreSQL v%s\n", cl.ServerVersion())
+		fmt.Printf("Conneced to %s\n", cl.ServerVersion())
 	}
 
 	fmt.Println("Checking database objects...")

pkg/client/client.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	neturl "net/url"
 	"reflect"
+	"regexp"
 	"strings"
 	"time"
 
@@ -17,10 +18,19 @@ import (
 	"github.com/sosedoff/pgweb/pkg/statements"
 )
 
+var (
+	postgresSignature = regexp.MustCompile(`(?i)postgresql ([\d\.]+)\s`)
+	postgresType      = "PostgreSQL"
+
+	cockroachSignature = regexp.MustCompile(`(?i)cockroachdb ccl v([\d\.]+)\s`)
+	cockroachType      = "CockroachDB"
+)
+
 type Client struct {
 	db               *sqlx.DB
 	tunnel           *Tunnel
 	serverVersion    string
+	serverType       string
 	lastQueryTime    time.Time
 	External         bool
 	History          []history.Record `json:"history"`
@@ -109,6 +119,11 @@ func NewFromUrl(url string, sshInfo *shared.SSHInfo) (*Client, error) {
 		fmt.Println("Creating a new client for:", url)
 	}
 
+	uri, err := neturl.Parse(url)
+	if err == nil && uri.Path == "" {
+		return nil, fmt.Errorf("Database name is not provided")
+	}
+
 	db, err := sqlx.Open("postgres", url)
 	if err != nil {
 		return nil, err
@@ -132,7 +147,22 @@ func (client *Client) setServerVersion() {
 	}
 
 	version := res.Rows[0][0].(string)
-	client.serverVersion = strings.Split(version, " ")[1]
+
+	// Detect postgresql
+	matches := postgresSignature.FindAllStringSubmatch(version, 1)
+	if len(matches) > 0 {
+		client.serverType = postgresType
+		client.serverVersion = matches[0][1]
+		return
+	}
+
+	// Detect cockroachdb
+	matches = cockroachSignature.FindAllStringSubmatch(version, 1)
+	if len(matches) > 0 {
+		client.serverType = cockroachType
+		client.serverVersion = matches[0][1]
+		return
+	}
 }
 
 func (client *Client) Test() error {
@@ -191,18 +221,45 @@ func (client *Client) TableRows(table string, opts RowsOptions) (*Result, error)
 	return client.query(sql)
 }
 
+func (client *Client) EstimatedTableRowsCount(table string, opts RowsOptions) (*Result, error) {
+	schema, table := getSchemaAndTable(table)
+	sql := fmt.Sprintf(`SELECT reltuples FROM pg_class WHERE oid = '%s.%s'::regclass;`, schema, table)
+
+	result, err := client.query(sql)
+	if err != nil {
+		return nil, err
+	}
+	// float64 to int64 conversion
+	estimatedRowsCount := result.Rows[0][0].(float64)
+	result.Rows[0] = Row{int64(estimatedRowsCount)}
+
+	return result, nil
+}
+
 func (client *Client) TableRowsCount(table string, opts RowsOptions) (*Result, error) {
 	schema, table := getSchemaAndTable(table)
 	sql := fmt.Sprintf(`SELECT COUNT(1) FROM "%s"."%s"`, schema, table)
 
 	if opts.Where != "" {
 		sql += fmt.Sprintf(" WHERE %s", opts.Where)
+	} else if client.serverType == postgresType {
+		tableInfo, err := client.TableInfo(table)
+		if err != nil {
+			return nil, err
+		}
+		estimatedRowsCount := tableInfo.Rows[0][3].(float64)
+		if estimatedRowsCount > 100000 {
+			return client.EstimatedTableRowsCount(table, opts)
+		}
 	}
 
 	return client.query(sql)
 }
 
 func (client *Client) TableInfo(table string) (*Result, error) {
+	if client.serverType == cockroachType {
+		return client.query(statements.TableInfoCockroach)
+	}
 	schema, table := getSchemaAndTable(table)
 	return client.query(statements.TableInfo, fmt.Sprintf(`"%s"."%s"`, schema, table))
 }
@@ -231,9 +288,11 @@ func (client *Client) TableConstraints(table string) (*Result, error) {
 
 // Returns all active queriers on the server
 func (client *Client) Activity() (*Result, error) {
-	chunks := strings.Split(client.serverVersion, ".")
-	version := strings.Join(chunks[0:2], ".")
+	if client.serverType == cockroachType {
+		return client.query("SHOW QUERIES")
+	}
 
+	version := getMajorMinorVersion(client.serverVersion)
 	query := statements.Activity[version]
 	if query == "" {
 		query = statements.Activity["default"]
@@ -268,7 +327,7 @@ func (client *Client) SetReadOnlyMode() error {
 }
 
 func (client *Client) ServerVersion() string {
-	return client.serverVersion
+	return fmt.Sprintf("%s %s", client.serverType, client.serverVersion)
 }
 
 func (client *Client) query(query string, args ...interface{}) (*Result, error) {

pkg/client/client_test.go

@@ -278,6 +278,35 @@ func test_TableInfo(t *testing.T) {
 	assert.Equal(t, 1, len(res.Rows))
 }
 
+func test_EstimatedTableRowsCount(t *testing.T) {
+	var count int64 = 15
+	res, err := testClient.EstimatedTableRowsCount("books", RowsOptions{})
+
+	assert.Equal(t, nil, err)
+	assert.Equal(t, []string{"reltuples"}, res.Columns)
+	assert.Equal(t, []Row{Row{count}}, res.Rows)
+}
+
+func test_TableRowsCount(t *testing.T) {
+	var count int64 = 15
+	res, err := testClient.TableRowsCount("books", RowsOptions{})
+
+	assert.Equal(t, nil, err)
+	assert.Equal(t, []string{"count"}, res.Columns)
+	assert.Equal(t, []Row{Row{count}}, res.Rows)
+}
+
+func test_TableRowsCountWithLargeTable(t *testing.T) {
+	var count int64 = 100010
+	testClient.db.MustExec(`create table large_table as select s from generate_Series(1,100010) s;`)
+	testClient.db.MustExec(`VACUUM large_table;`)
+	res, err := testClient.TableRowsCount("large_table", RowsOptions{})
+
+	assert.Equal(t, nil, err)
+	assert.Equal(t, []string{"reltuples"}, res.Columns)
+	assert.Equal(t, []Row{Row{count}}, res.Rows)
+}
+
 func test_TableIndexes(t *testing.T) {
 	res, err := testClient.TableIndexes("books")
 
@@ -400,6 +429,9 @@ func TestAll(t *testing.T) {
 	test_Table(t)
 	test_TableRows(t)
 	test_TableInfo(t)
+	test_EstimatedTableRowsCount(t)
+	test_TableRowsCount(t)
+	test_TableRowsCountWithLargeTable(t)
 	test_TableIndexes(t)
 	test_TableConstraints(t)
 	test_Query(t)