release-2.1: assorted missing telemetry

docs/generated/sql/bnf/stmt_block.bnf

@@ -558,6 +558,7 @@ unreserved_keyword ::=
 	| 'DAY'
 	| 'DEALLOCATE'
 	| 'DELETE'
+	| 'DEFERRED'
 	| 'DISCARD'
 	| 'DOMAIN'
 	| 'DOUBLE'
@@ -589,6 +590,7 @@ unreserved_keyword ::=
 	| 'HIGH'
 	| 'HISTOGRAM'
 	| 'HOUR'
+	| 'IMMEDIATE'
 	| 'IMPORT'
 	| 'INCREMENT'
 	| 'INCREMENTAL'
@@ -634,6 +636,7 @@ unreserved_keyword ::=
 	| 'OF'
 	| 'OFF'
 	| 'OID'
+	| 'OIDS'
 	| 'OIDVECTOR'
 	| 'OPERATOR'
 	| 'OPTION'

pkg/server/telemetry/features.go

@@ -18,6 +18,8 @@ import (
 	"fmt"
 	"sync/atomic"
 
+	"github.com/cockroachdb/cockroach/pkg/sql/pgwire/pgerror"
+	"github.com/cockroachdb/cockroach/pkg/util/log"
 	"github.com/cockroachdb/cockroach/pkg/util/syncutil"
 )
 
@@ -123,3 +125,36 @@ func GetAndResetFeatureCounts(quantize bool) map[string]int32 {
 	}
 	return m
 }
+
+// RecordError takes an error and increments the corresponding count
+// for its error code, and, if it is an unimplemented or internal
+// error, the count for that feature or the internal error's shortened
+// stack trace.
+func RecordError(err error) {
+	if err == nil {
+		return
+	}
+
+	if pgErr, ok := pgerror.GetPGCause(err); ok {
+		Count("errorcodes." + pgErr.Code)
+
+		if details := pgErr.InternalCommand; details != "" {
+			var prefix string
+			switch pgErr.Code {
+			case pgerror.CodeFeatureNotSupportedError:
+				prefix = "unimplemented."
+			case pgerror.CodeInternalError:
+				prefix = "internalerror."
+			default:
+				prefix = "othererror." + pgErr.Code + "."
+			}
+			Count(prefix + details)
+		}
+	} else {
+		typ := log.ErrorSource(err)
+		if typ == "" {
+			typ = "unknown"
+		}
+		Count("othererror." + typ)
+	}
+}

pkg/server/updates_test.go

@@ -296,6 +296,11 @@ func TestReportUsage(t *testing.T) {
 		) {
 			t.Fatal(err)
 		}
+		if _, err := db.Exec(`SELECT crdb_internal.set_vmodule('invalid')`); !testutils.IsError(
+			err, "comma-separated list",
+		) {
+			t.Fatal(err)
+		}
 		// If the vtable ever gets supported, change to pick one that is not supported yet.
 		if _, err := db.Exec(`SELECT * FROM pg_catalog.pg_stat_wal_receiver`); !testutils.IsError(
 			err, "virtual schema table not implemented",
@@ -528,7 +533,11 @@ func TestReportUsage(t *testing.T) {
 		"unimplemented.#9148":                                10,
 		"internalerror.":                                     10,
 		"othererror.builtins.go":                             10,
+		"othererror." +
+			pgerror.CodeDataExceptionError +
+			".crdb_internal.set_vmodule()": 10,
 		"errorcodes.blah":                                    10,
+		"errorcodes." + pgerror.CodeDataExceptionError:       10,
 		"errorcodes." + pgerror.CodeInternalError:            10,
 		"errorcodes." + pgerror.CodeSyntaxError:              10,
 		"errorcodes." + pgerror.CodeFeatureNotSupportedError: 10,
@@ -665,6 +674,7 @@ func TestReportUsage(t *testing.T) {
 		`[true,false,true] SELECT _ / _`,
 		`[true,false,true] SELECT crdb_internal.force_assertion_error(_)`,
 		`[true,false,true] SELECT crdb_internal.force_error(_, $1)`,
+		`[true,false,true] SELECT crdb_internal.set_vmodule(_)`,
 		`[true,true,false] SELECT * FROM _ WHERE (_ = _) AND (_ = _)`,
 		`[true,true,false] SELECT * FROM _ WHERE (_ = length($1::STRING)) OR (_ = $2)`,
 		`[true,true,false] SELECT _ FROM _ WHERE (_ = _) AND (lower(_) = lower(_))`,
@@ -709,6 +719,7 @@ func TestReportUsage(t *testing.T) {
 			`SELECT _ / _`,
 			`SELECT crdb_internal.force_assertion_error(_)`,
 			`SELECT crdb_internal.force_error(_, $1)`,
+			`SELECT crdb_internal.set_vmodule(_)`,
 			`SET CLUSTER SETTING "server.time_until_store_dead" = _`,
 			`SET CLUSTER SETTING "diagnostics.reporting.send_crash_reports" = _`,
 			`SET application_name = _`,

pkg/sql/conn_executor.go

@@ -302,37 +302,6 @@ func (s *Server) Start(ctx context.Context, stopper *stop.Stopper) {
 	s.PeriodicallyClearStmtStats(ctx, stopper)
 }
 
-// recordError takes an error and increments the corresponding count
-// for its error code, and, if it is an unimplemented or internal
-// error, the count for that feature or the internal error's shortened
-// stack trace.
-func (s *Server) recordError(err error) {
-	if err == nil {
-		return
-	}
-
-	if pgErr, ok := pgerror.GetPGCause(err); ok {
-		telemetry.Count("errorcodes." + pgErr.Code)
-
-		switch pgErr.Code {
-		case pgerror.CodeFeatureNotSupportedError:
-			if feature := pgErr.InternalCommand; feature != "" {
-				telemetry.Count("unimplemented." + feature)
-			}
-		case pgerror.CodeInternalError:
-			if trace := pgErr.InternalCommand; trace != "" {
-				telemetry.Count("internalerror." + trace)
-			}
-		}
-	} else {
-		typ := log.ErrorSource(err)
-		if typ == "" {
-			typ = "unknown"
-		}
-		telemetry.Count("othererror." + typ)
-	}
-}
-
 // ResetStatementStats resets the executor's collected statement statistics.
 func (s *Server) ResetStatementStats(ctx context.Context) {
 	s.sqlStats.resetStats(ctx)
@@ -1290,12 +1259,12 @@ func (ex *connExecutor) run(
 				ex.sessionEventf(ex.Ctx(), "execution error: %s", pe.errorCause())
 			}
 			if resErr == nil && ok {
-				ex.server.recordError(pe.errorCause())
+				telemetry.RecordError(pe.errorCause())
 				// Depending on whether the result has the error already or not, we have
 				// to call either Close or CloseWithErr.
 				res.CloseWithErr(pe.errorCause())
 			} else {
-				ex.server.recordError(resErr)
+				telemetry.RecordError(resErr)
 				res.Close(stateToTxnStatusIndicator(ex.machine.CurState()))
 			}
 		} else {

pkg/sql/conn_executor_exec.go

@@ -26,6 +26,7 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/base"
 	"github.com/cockroachdb/cockroach/pkg/internal/client"
 	"github.com/cockroachdb/cockroach/pkg/roachpb"
+	"github.com/cockroachdb/cockroach/pkg/server/telemetry"
 	"github.com/cockroachdb/cockroach/pkg/sql/coltypes"
 	"github.com/cockroachdb/cockroach/pkg/sql/pgwire/pgerror"
 	"github.com/cockroachdb/cockroach/pkg/sql/sem/tree"
@@ -1207,7 +1208,7 @@ func (ex *connExecutor) runShowSyntax(
 			commErr = res.AddRow(ctx, tree.Datums{tree.NewDString(field), tree.NewDString(msg)})
 			return nil
 		},
-		ex.server.recordError, /* reportErr */
+		telemetry.RecordError, /* reportErr */
 	); err != nil {
 		res.SetError(err)
 	}

pkg/sql/parser/parse_test.go

@@ -2548,6 +2548,7 @@ func TestUnimplementedSyntax(t *testing.T) {
 		{`CREATE OPERATOR a`, 0, `create operator`},
 		{`CREATE PUBLICATION a`, 0, `create publication`},
 		{`CREATE RULE a`, 0, `create rule`},
+		{`CREATE SCHEMA a`, 26443, `create`},
 		{`CREATE SERVER a`, 0, `create server`},
 		{`CREATE SUBSCRIPTION a`, 0, `create subscription`},
 		{`CREATE TEXT SEARCH a`, 7821, `create text`},
@@ -2566,6 +2567,7 @@ func TestUnimplementedSyntax(t *testing.T) {
 		{`DROP OPERATOR a`, 0, `drop operator`},
 		{`DROP PUBLICATION a`, 0, `drop publication`},
 		{`DROP RULE a`, 0, `drop rule`},
+		{`DROP SCHEMA a`, 26443, `drop`},
 		{`DROP SERVER a`, 0, `drop server`},
 		{`DROP SUBSCRIPTION a`, 0, `drop subscription`},
 		{`DROP TEXT SEARCH a`, 7821, `drop text`},
@@ -2586,11 +2588,26 @@ func TestUnimplementedSyntax(t *testing.T) {
 		{`CREATE TEMP VIEW a AS SELECT b`, 5807, ``},
 		{`CREATE TEMP SEQUENCE a`, 5807, ``},
 
+		{`CREATE TABLE a(LIKE b)`, 30840, ``},
+
+		{`CREATE TABLE a(b INT) WITH OIDS`, 0, `create table with oids`},
+		{`CREATE TABLE a(b INT) WITH foo = bar`, 0, `create table with foo`},
+
+		{`CREATE TABLE a AS SELECT b WITH NO DATA`, 0, `create table as with no data`},
+
 		{`CREATE TABLE a(b INT AS (123) VIRTUAL)`, 0, `virtual computed columns`},
 		{`CREATE TABLE a(b INT REFERENCES c(x) MATCH FULL`, 0, `references match full`},
 		{`CREATE TABLE a(b INT REFERENCES c(x) MATCH PARTIAL`, 0, `references match partial`},
 		{`CREATE TABLE a(b INT REFERENCES c(x) MATCH SIMPLE`, 0, `references match simple`},
 
+		{`CREATE TABLE a(b INT, FOREIGN KEY (b) REFERENCES c(x) DEFERRABLE)`, 31632, `deferrable`},
+		{`CREATE TABLE a(b INT, FOREIGN KEY (b) REFERENCES c(x) INITIALLY DEFERRED)`, 31632, `initially deferred`},
+		{`CREATE TABLE a(b INT, FOREIGN KEY (b) REFERENCES c(x) INITIALLY IMMEDIATE)`, 31632, `initially immediate`},
+		{`CREATE TABLE a(b INT, FOREIGN KEY (b) REFERENCES c(x) DEFERRABLE INITIALLY DEFERRED)`, 31632, `initially deferred`},
+		{`CREATE TABLE a(b INT, FOREIGN KEY (b) REFERENCES c(x) DEFERRABLE INITIALLY IMMEDIATE)`, 31632, `initially immediate`},
+		{`CREATE TABLE a(b INT, UNIQUE (b) DEFERRABLE)`, 31632, `deferrable`},
+		{`CREATE TABLE a(b INT, CHECK (b > 0) DEFERRABLE)`, 31632, `deferrable`},
+
 		{`CREATE SEQUENCE a AS DOUBLE PRECISION`, 25110, `FLOAT8`},
 		{`CREATE SEQUENCE a OWNED BY b`, 26382, ``},