chore: import upstream snapshot with attribution

testing/generation/command_docs/create_row_tests.go

@@ -0,0 +1,132 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/jackc/pgx/v5"
+
+	"github.com/dolthub/doltgresql/testing/generation/utils"
+	framework "github.com/dolthub/doltgresql/testing/go"
+)
+
+// GenerateRowTests uses the given StatementGenerator to return a random set of queries along with their results that
+// were retrieved from a Postgres instance. Uses the MaxTestCount to determine the number of tests to generate. The
+// returned map uses the query as the key, with the results being the value.
+func GenerateRowTests(stmtGen utils.StatementGenerator) (map[string][]sql.Row, error) {
+	randomInts, err := utils.GenerateRandomInts(MaxTestCount, stmtGen.Permutations())
+	if err != nil {
+		return nil, err
+	}
+	allResults := make(map[string][]sql.Row)
+	for _, randomInt := range randomInts {
+		stmtGen.SetConsumeIterations(randomInt)
+		generatedString := stmtGen.String()
+		result, err := GetRowResults(generatedString)
+		if err != nil {
+			return nil, err
+		}
+		allResults[generatedString] = result
+	}
+	return allResults, nil
+}
+
+// GetSynopsisStatementGenerator returns the StatementGenerator for the given synopsis. The synopsisData should be the
+// string that has been loaded from the synopses directory. includeRepetition states whether repetition is included in
+// the returned StatementGenerator.
+func GetSynopsisStatementGenerator(synopsisData string, prefix string, includeRepetition bool) (utils.StatementGenerator, error) {
+	scanner := NewScanner(synopsisData)
+	tokens, err := scanner.Process()
+	if err != nil {
+		return nil, err
+	}
+	stmtGen, err := utils.ParseTokens(tokens, includeRepetition)
+	if err != nil {
+		return nil, err
+	}
+	// Not all variables have their definitions set in the synopsis, so we'll handle them here
+	unsetVariables, err := utils.UnsetVariables(stmtGen)
+	if err != nil {
+		return nil, err
+	}
+	customVariableDefinitions := make(map[string]utils.StatementGenerator)
+	for _, unsetVariable := range unsetVariables {
+		// Check for a specific definition first
+		if prefixVariables, ok := PrefixCustomVariables[prefix]; ok {
+			if variableDefinition, ok := prefixVariables[unsetVariable]; ok {
+				customVariableDefinitions[unsetVariable] = variableDefinition
+				continue
+			}
+		}
+		// Check the global definitions if there isn't a specific definition
+		if variableDefinition, ok := GlobalCustomVariables[unsetVariable]; ok {
+			customVariableDefinitions[unsetVariable] = variableDefinition
+			continue
+		}
+	}
+	if err = utils.ApplyVariableDefinition(stmtGen, customVariableDefinitions); err != nil {
+		return nil, err
+	}
+	return stmtGen, nil
+}
+
+// LoadSynopsis loads the given synopsis from the synopses directory. The synopsis name may be the file name, or the
+// name of the statement (also known as the prefix). Case-insensitive.
+func LoadSynopsis(synopsis string) (data string, prefix string, err error) {
+	prefix = strings.ToUpper(
+		strings.ReplaceAll(
+			strings.ReplaceAll(
+				synopsis,
+				".txt",
+				"",
+			),
+			"_",
+			" ",
+		),
+	)
+	fileName := strings.ToLower(strings.ReplaceAll(prefix+".txt", " ", "_"))
+	parentFolder, err := GetCommandDocsFolder()
+	if err != nil {
+		return "", "", err
+	}
+	dataBytes, err := parentFolder.ReadFileFromDirectory("synopses", fileName)
+	if err != nil {
+		return "", "", err
+	}
+	return strings.TrimSpace(string(dataBytes)), prefix, nil
+}
+
+// GetRowResults runs the query against a Postgres server and returns the resulting rows.
+func GetRowResults(query string) ([]sql.Row, error) {
+	var err error
+	ctx := context.Background()
+	if postgresVerificationConnection == nil {
+		connectionString := fmt.Sprintf("postgres://postgres:password@127.0.0.1:%d/", 5432)
+		postgresVerificationConnection, err = pgx.Connect(ctx, connectionString)
+		if err != nil {
+			return nil, err
+		}
+	}
+	pgxRows, err := postgresVerificationConnection.Query(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+	readRows, _, err := framework.ReadRows(pgxRows, true)
+	return readRows, err
+}

testing/generation/command_docs/create_tests.go

@@ -0,0 +1,255 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"math/big"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/dolthub/vitess/go/vt/sqlparser"
+	"github.com/jackc/pgx/v5"
+	"github.com/sergi/go-diff/diffmatchpatch"
+	"golang.org/x/text/cases"
+	"golang.org/x/text/language"
+
+	"github.com/dolthub/doltgresql/postgres/parser/parser"
+	"github.com/dolthub/doltgresql/server/ast"
+	"github.com/dolthub/doltgresql/testing/generation/utils"
+)
+
+const TestHeader = `// Copyright %d Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func Test%s(t *testing.T) {
+	tests := []QueryParses{
+`
+
+const TestFooter = `	}
+	RunTests(t, tests)
+}
+`
+
+const MaxTestCount = 10000
+
+// GenerateTestsFromSynopses generates a test file in the output directory for each file in the synopses directory.
+func GenerateTestsFromSynopses(repetitionDisabled ...string) (err error) {
+	parentFolder, err := GetCommandDocsFolder()
+	if err != nil {
+		return err
+	}
+	fileInfos, err := parentFolder.ReadDir("synopses")
+	if err != nil {
+		return err
+	}
+	removeComments := regexp.MustCompile(`\/\/[^\r\n]*\r?\n?`)
+
+FileLoop:
+	for _, fileInfo := range fileInfos {
+		prefix := strings.ToUpper(
+			strings.ReplaceAll(
+				strings.ReplaceAll(
+					fileInfo.Name(),
+					".txt",
+					"",
+				),
+				"_",
+				" ",
+			),
+		)
+		utils.PrintSectionMarker(prefix, '+', 80)
+		data, nErr := parentFolder.ReadFileFromDirectory("synopses", fileInfo.Name())
+		if nErr != nil {
+			err = errors.Join(err, nErr)
+			continue FileLoop
+		}
+		dataStr := strings.TrimSpace(string(data))
+		scanner := NewScanner(dataStr)
+		tokens, nErr := scanner.Process()
+		if nErr != nil {
+			err = errors.Join(err, nErr)
+			continue FileLoop
+		}
+		scannerString := scanner.String()
+		if removeComments.ReplaceAllString(dataStr, "") != scannerString {
+			sb := strings.Builder{}
+			dmp := diffmatchpatch.New()
+			diffs := dmp.DiffMain(dataStr, scannerString, true)
+			whitespaceOnly := true
+			for _, diff := range diffs {
+				if diff.Type != diffmatchpatch.DiffEqual && diff.Text != " " && diff.Text != "\n" {
+					whitespaceOnly = false
+				}
+			}
+			if whitespaceOnly {
+				sb.WriteString(utils.SectionMarker("Whitespace Differences", '-', 80))
+			} else {
+				sb.WriteString(dmp.DiffPrettyText(diffs))
+			}
+			fmt.Println(sb.String())
+			err = errors.Join(err, errors.New(sb.String()))
+			continue FileLoop
+		}
+		includeRepetition := len(repetitionDisabled) == 0 || repetitionDisabled[0] != "*"
+		for _, bans := range repetitionDisabled {
+			if strings.EqualFold(bans, prefix) {
+				includeRepetition = false
+				break
+			}
+		}
+		stmtGen, nErr := utils.ParseTokens(tokens, includeRepetition)
+		if nErr != nil {
+			err = errors.Join(err, nErr)
+			continue FileLoop
+		}
+		// Not all variables have their definitions set in the synopsis, so we'll handle them here
+		unsetVariables, nErr := utils.UnsetVariables(stmtGen)
+		if nErr != nil {
+			err = errors.Join(err, nErr)
+			continue FileLoop
+		}
+		customVariableDefinitions := make(map[string]utils.StatementGenerator)
+		for _, unsetVariable := range unsetVariables {
+			// Check for a specific definition first
+			if prefixVariables, ok := PrefixCustomVariables[prefix]; ok {
+				if variableDefinition, ok := prefixVariables[unsetVariable]; ok {
+					customVariableDefinitions[unsetVariable] = variableDefinition
+					continue
+				}
+			}
+			// Check the global definitions if there isn't a specific definition
+			if variableDefinition, ok := GlobalCustomVariables[unsetVariable]; ok {
+				customVariableDefinitions[unsetVariable] = variableDefinition
+				continue
+			}
+		}
+		if nErr = utils.ApplyVariableDefinition(stmtGen, customVariableDefinitions); nErr != nil {
+			err = errors.Join(err, nErr)
+			continue FileLoop
+		}
+		sb := strings.Builder{}
+		sb.WriteString(fmt.Sprintf(TestHeader, time.Now().Year(),
+			strings.ReplaceAll(cases.Title(language.English).String(strings.ToLower(prefix)), " ", "")))
+
+		permutations := stmtGen.Permutations()
+		if permutations.Cmp(big.NewInt(MaxTestCount)) <= 0 {
+			result, nErr := GetQueryResult(stmtGen.String())
+			if nErr != nil {
+				err = errors.Join(err, nErr)
+				continue FileLoop
+			}
+			sb.WriteString(result)
+			for stmtGen.Consume() {
+				result, nErr = GetQueryResult(stmtGen.String())
+				if nErr != nil {
+					err = errors.Join(err, nErr)
+					continue FileLoop
+				}
+				sb.WriteString(result)
+			}
+		} else {
+			randomInts, nErr := utils.GenerateRandomInts(MaxTestCount, permutations)
+			if nErr != nil {
+				err = errors.Join(err, nErr)
+			}
+			for _, randomInt := range randomInts {
+				stmtGen.SetConsumeIterations(randomInt)
+				result, nErr := GetQueryResult(stmtGen.String())
+				if nErr != nil {
+					err = errors.Join(err, nErr)
+					continue FileLoop
+				}
+				sb.WriteString(result)
+			}
+		}
+
+		sb.WriteString(TestFooter)
+		outputFileName := strings.ToLower(strings.ReplaceAll(prefix, " ", "_"))
+		if nErr = parentFolder.WriteFileToDirectory("output", outputFileName+"_test.go", []byte(sb.String()), 0644); nErr != nil {
+			err = errors.Join(err, nErr)
+			continue FileLoop
+		}
+	}
+	return err
+}
+
+var postgresVerificationConnection *pgx.Conn
+
+// GetQueryResult runs the query against a Postgres server to validate that the query is syntactically valid. It then
+// tests the query against the Postgres parser and Postgres-Vitess AST converter to check the current level of support.
+// It returns a string that may be inserted directly into a test source file (two tabs are prefixed).
+func GetQueryResult(query string) (string, error) {
+	var err error
+	ctx := context.Background()
+	if postgresVerificationConnection == nil {
+		connectionString := fmt.Sprintf("postgres://postgres:password@127.0.0.1:%d/", 5432)
+		postgresVerificationConnection, err = pgx.Connect(ctx, connectionString)
+		if err != nil {
+			return "", err
+		}
+	}
+	testQuery := fmt.Sprintf("DO $SYNTAX_CHECK$ BEGIN RETURN; %s; END; $SYNTAX_CHECK$;", query)
+	_, err = postgresVerificationConnection.Exec(ctx, testQuery)
+	if err != nil && strings.Contains(err.Error(), "syntax error") {
+		// We only care about syntax errors, as statements may rely on internal state, which is not what we're testing
+		// There are statements that will not execute inside our DO block due to how Postgres handles some queries, so
+		// to confirm that they're syntax errors, we'll run them outside the block. All such queries should be
+		// non-destructive, so this should be safe. All other queries will still return a syntax error.
+		_, err = postgresVerificationConnection.Exec(ctx, query)
+		// Run a ROLLBACK as some commands may put the connection (not the database) in a bad state
+		_, _ = postgresVerificationConnection.Exec(ctx, "ROLLBACK;")
+		if err != nil && strings.Contains(err.Error(), "syntax error") {
+			return "", fmt.Errorf("%s\n%s", err, query)
+		}
+	}
+	formattedQuery := strings.ReplaceAll(query, `"`, `\"`)
+	statements, err := parser.Parse(query)
+	if err != nil || len(statements) == 0 {
+		return fmt.Sprintf("\t\tUnimplemented(\"%s\"),\n", formattedQuery), nil
+	}
+	for _, statement := range statements {
+		vitessAST, err := func() (vitessAST sqlparser.Statement, err error) {
+			defer func() {
+				if recoverVal := recover(); recoverVal != nil {
+					vitessAST = nil
+				}
+			}()
+			return ast.Convert(statement)
+		}()
+		if err != nil || vitessAST == nil {
+			return fmt.Sprintf("\t\tParses(\"%s\"),\n", formattedQuery), nil
+		}
+	}
+	return fmt.Sprintf("\t\tConverts(\"%s\"),\n", formattedQuery), nil
+}

testing/generation/command_docs/custom_variables.go

@@ -0,0 +1,145 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"strings"
+
+	"github.com/dolthub/doltgresql/testing/generation/utils"
+)
+
+// GlobalCustomVariables are variable definitions that are used when a synopsis does not define the definition itself,
+// and there isn't a more specific definition in PrefixCustomVariables.
+var GlobalCustomVariables = map[string]utils.StatementGenerator{
+	"access_method_type":  customDefinition(`TABLE | INDEX`),
+	"agg_argmode":         customDefinition(`IN | VARIADIC`),
+	"routine_argmode":     customDefinition(`IN | VARIADIC | OUT | INOUT`),
+	"argtype":             customDefinition(`FLOAT8`),
+	"boolean":             customDefinition(`true`),
+	"cache":               customDefinition(`1`),
+	"code":                customDefinition(`'code'`),
+	"collatable":          customDefinition(`true`),
+	"collation":           customDefinition(`en_US`),
+	"column_definition":   customDefinition(`v1 INTEGER`),
+	"column_number":       customDefinition(`1`),
+	"connlimit":           customDefinition(`-1`),
+	"cycle_mark_default":  customDefinition(`'cycle_mark_default'`),
+	"cycle_mark_value":    customDefinition(`'cycle_mark_value'`),
+	"delete":              customDefinition(`DELETE FROM tablename`),
+	"dest_encoding":       customDefinition(`'UTF8'`),
+	"domain_constraint":   customDefinition(`CONSTRAINT name CHECK (condition)`),
+	"element":             customDefinition(`element_type`),
+	"execution_cost":      customDefinition(`10`),
+	"existing_enum_value": customDefinition(`'1'`),
+	"filter_value":        customDefinition(`'Active'`),
+	"from_item_recursive": customDefinition(`function_name()`),
+	"increment":           customDefinition(`1`),
+	"insert":              customDefinition(`INSERT INTO tablename VALUES (1)`),
+	"integer":             customDefinition(`1`),
+	"internallength":      customDefinition(`16`),
+	"join_type":           customDefinition(`[ INNER ] JOIN | LEFT [ OUTER ] JOIN | RIGHT [ OUTER ] JOIN | FULL [ OUTER ] JOIN`),
+	"large_object_oid":    customDefinition(`99999`),
+	"loid":                customDefinition(`99999`),
+	"maxvalue":            customDefinition(`1`),
+	"minvalue":            customDefinition(`1`),
+	"mstate_data_size":    customDefinition(`16`),
+	"neighbor_enum_value": customDefinition(`'1'`),
+	"new_enum_value":      customDefinition(`'1'`),
+	"numeric_literal":     customDefinition(`1`),
+	"operator":            customDefinition(`+`),
+	"output_expression":   customDefinition(`colname`),
+	"payload":             customDefinition(`'payload'`),
+	"preferred":           customDefinition(`true`),
+	"query":               customDefinition(`SELECT 1`),
+	"restart":             customDefinition(`0`),
+	"select":              customDefinition(`SELECT 1`),
+	"sequence_options":    customDefinition(`NO MINVALUE`),
+	"snapshot_id":         customDefinition(`'snapshot_id'`),
+	"sort_operator":       customDefinition(`>`),
+	"source_encoding":     customDefinition(`'UTF8'`),
+	"source_query":        customDefinition(`SELECT 1`),
+	"sql_body":            customDefinition(`BEGIN ATOMIC END | RETURN 1`),
+	"start":               customDefinition(`0`),
+	"state_data_size":     customDefinition(`16`),
+	"storage_parameter":   customDefinition(`fillfactor`),
+	"strategy_number":     customDefinition(`3`),
+	"string_literal":      customDefinition(`'str'`),
+	"sub-SELECT":          customDefinition(`SELECT 1`),
+	"support_number":      customDefinition(`3`),
+	"transaction_id":      customDefinition(`'id'`),
+	"oid":                 customDefinition(`99999`),
+	"operator_name":       customDefinition(`@@`),
+	"result_rows":         customDefinition(`10`),
+	"uid":                 customDefinition(`1`),
+	"update":              customDefinition(`UPDATE tablename SET x = 1`),
+	"values":              customDefinition(`VALUES (1)`),
+	"view_option_name":    customDefinition(`check_option | security_barrier | security_invoker`),
+	"with_query":          customDefinition(`queryname AS (select)`),
+}
+
+var PrefixCustomVariables = map[string]map[string]utils.StatementGenerator{
+	"ALTER FOREIGN TABLE": {
+		"index_parameters": customDefinition(`USING INDEX TABLESPACE tablespace_name`),
+	},
+	"ALTER OPERATOR": {
+		"name": customDefinition(`@@`),
+	},
+	"ALTER STATISTICS": {
+		"new_target": customDefinition(`1`),
+	},
+	"CREATE OPERATOR": {
+		"name": customDefinition(`@@`),
+	},
+	"CREATE RULE": {
+		"command": customDefinition(`SELECT 'abc'`),
+	},
+	"CREATE SCHEMA": {
+		"schema_element": customDefinition(`CREATE TABLE tablename()`),
+	},
+	"DROP OPERATOR": {
+		"name": customDefinition(`@@`),
+	},
+	"EXPLAIN": {
+		"statement": customDefinition(`SELECT 1 | INSERT INTO tablename VALUES (1)`),
+	},
+	"MERGE": {
+		"query": customDefinition(`SELECT 1`),
+	},
+	"PREPARE": {
+		"statement": customDefinition(`SELECT 1 | INSERT INTO tablename VALUES (1)`),
+	},
+	"SET": {
+		"value": customDefinition(`1`),
+	},
+}
+
+// customDefinition returns a StatementGenerator for a custom variable definition. The variable definition should follow
+// the same layout format as synopses.
+func customDefinition(str string) utils.StatementGenerator {
+	str = strings.TrimSpace(str)
+	scanner := NewScanner(str)
+	tokens, err := scanner.Process()
+	if err != nil {
+		panic(err)
+	}
+	stmtGen, err := utils.ParseTokens(tokens, true)
+	if err != nil {
+		panic(err)
+	}
+	if stmtGen == nil {
+		panic("definition did not create a statement generator")
+	}
+	return stmtGen
+}

testing/generation/command_docs/download.go

@@ -0,0 +1,107 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/dolthub/doltgresql/testing/generation/utils"
+
+	"github.com/PuerkitoBio/goquery"
+	"golang.org/x/net/html"
+)
+
+const (
+	postgresBaseLink = `https://www.postgresql.org/docs/15/`
+	commandPageLink  = `sql-commands.html`
+)
+
+type Link struct {
+	CommandName string
+	Link        string
+}
+
+// DownloadAllSynopses downloads and writes all synopses from the internet. It is assumed that this will be run from
+// within an IDE, and will download to the `commands_docs/synopses` folder. Uses `postgresBaseLink` to determine which
+// version of the command page will be downloaded, and `commandPageLink` specifies the exact page that the commands are
+// contained on. This function is only necessary if we're upgrading the Postgres version.
+func DownloadAllSynopses() {
+	commandDocument, err := FetchDocument(postgresBaseLink + commandPageLink)
+	if err != nil {
+		panic(err)
+	}
+	var allLinks []Link
+	_ = commandDocument.Find(".toc a").Each(func(i int, e *goquery.Selection) {
+		href, exists := e.Attr("href")
+		if exists {
+			allLinks = append(allLinks, Link{
+				CommandName: e.Text(),
+				Link:        postgresBaseLink + strings.Trim(href, `\/`),
+			})
+		}
+	})
+	for _, link := range allLinks {
+		linkDocument, err := FetchDocument(link.Link)
+		if err != nil {
+			panic(err)
+		}
+		synopsis := linkDocument.Find(".synopsis").First()
+		if strings.Contains(synopsis.Text(), "$") {
+			panic(fmt.Errorf("Synopsis has a $, which is unexpected:\n\n%s\n\n%s", link, synopsis.Text()))
+		}
+		synopsis.Find(".replaceable").Each(func(i int, e *goquery.Selection) {
+			e.SetText(fmt.Sprintf("$%s$", e.Text()))
+		})
+		func() {
+			fileLocation, err := GetCommandDocsFolder()
+			if err != nil {
+				fmt.Println(err.Error())
+				return
+			}
+			fileName := strings.ToLower(strings.ReplaceAll(link.CommandName, " ", "_"))
+			data := []byte(synopsis.Text())
+			if err = fileLocation.WriteFileToDirectory("synopses/%s.txt", fileName+".txt", data, 0644); err != nil {
+				fmt.Println(err.Error())
+			}
+			fmt.Printf("Downloaded: %s\n", link.Link)
+		}()
+	}
+}
+
+// FetchDocument fetches the document from the given link. The link should be a full HTTP/HTTPS URL.
+func FetchDocument(link string) (*goquery.Document, error) {
+	res, err := http.Get(link)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	node, err := html.Parse(res.Body)
+	if err != nil {
+		return nil, err
+	}
+	return goquery.NewDocumentFromNode(node), nil
+}
+
+// GetCommandDocsFolder returns the directory of this particular Go file: download.go. This is useful to locate relative
+// directories, such as the synopses folder. It is assumed that this will always be called from within an IDE.
+func GetCommandDocsFolder() (utils.RootFolderLocation, error) {
+	root, err := utils.GetRootFolder()
+	if err != nil {
+		return utils.RootFolderLocation{}, err
+	}
+	return root.MoveRoot("testing/generation/command_docs"), nil
+}

testing/generation/command_docs/main.go

@@ -0,0 +1,27 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	//DownloadAllSynopses()
+	err := GenerateTestsFromSynopses()
+	if err != nil {
+		fmt.Println(err.Error())
+	}
+}

testing/generation/command_docs/output/abort_test.go

@@ -0,0 +1,32 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAbort(t *testing.T) {
+	tests := []QueryParses{
+		Converts("ABORT"),
+		Converts("ABORT WORK"),
+		Converts("ABORT TRANSACTION"),
+		Converts("ABORT AND CHAIN"),
+		Converts("ABORT WORK AND CHAIN"),
+		Converts("ABORT TRANSACTION AND CHAIN"),
+		Converts("ABORT AND NO CHAIN"),
+		Converts("ABORT WORK AND NO CHAIN"),
+		Converts("ABORT TRANSACTION AND NO CHAIN"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_collation_test.go

@@ -0,0 +1,30 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterCollation(t *testing.T) {
+	tests := []QueryParses{
+		Parses("ALTER COLLATION name REFRESH VERSION"),
+		Parses("ALTER COLLATION name RENAME TO new_name"),
+		Parses("ALTER COLLATION name OWNER TO new_owner"),
+		Parses("ALTER COLLATION name OWNER TO CURRENT_ROLE"),
+		Parses("ALTER COLLATION name OWNER TO CURRENT_USER"),
+		Parses("ALTER COLLATION name OWNER TO SESSION_USER"),
+		Parses("ALTER COLLATION name SET SCHEMA new_schema"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_conversion_test.go

@@ -0,0 +1,29 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterConversion(t *testing.T) {
+	tests := []QueryParses{
+		Parses("ALTER CONVERSION name RENAME TO new_name"),
+		Parses("ALTER CONVERSION name OWNER TO new_owner"),
+		Parses("ALTER CONVERSION name OWNER TO CURRENT_ROLE"),
+		Parses("ALTER CONVERSION name OWNER TO CURRENT_USER"),
+		Parses("ALTER CONVERSION name OWNER TO SESSION_USER"),
+		Parses("ALTER CONVERSION name SET SCHEMA new_schema"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_database_test.go

@@ -0,0 +1,64 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterDatabase(t *testing.T) {
+	tests := []QueryParses{
+		Parses("ALTER DATABASE name"),
+		Parses("ALTER DATABASE name ALLOW_CONNECTIONS allowconn"),
+		Parses("ALTER DATABASE name WITH ALLOW_CONNECTIONS allowconn"),
+		Parses("ALTER DATABASE name CONNECTION LIMIT -1"),
+		Parses("ALTER DATABASE name WITH CONNECTION LIMIT -1"),
+		Parses("ALTER DATABASE name IS_TEMPLATE istemplate"),
+		Parses("ALTER DATABASE name WITH IS_TEMPLATE istemplate"),
+		Parses("ALTER DATABASE name ALLOW_CONNECTIONS allowconn ALLOW_CONNECTIONS allowconn"),
+		Parses("ALTER DATABASE name WITH ALLOW_CONNECTIONS allowconn ALLOW_CONNECTIONS allowconn"),
+		Parses("ALTER DATABASE name CONNECTION LIMIT -1 ALLOW_CONNECTIONS allowconn"),
+		Parses("ALTER DATABASE name WITH CONNECTION LIMIT -1 ALLOW_CONNECTIONS allowconn"),
+		Parses("ALTER DATABASE name IS_TEMPLATE istemplate ALLOW_CONNECTIONS allowconn"),
+		Parses("ALTER DATABASE name WITH IS_TEMPLATE istemplate ALLOW_CONNECTIONS allowconn"),
+		Parses("ALTER DATABASE name ALLOW_CONNECTIONS allowconn CONNECTION LIMIT -1"),
+		Parses("ALTER DATABASE name WITH ALLOW_CONNECTIONS allowconn CONNECTION LIMIT -1"),
+		Parses("ALTER DATABASE name CONNECTION LIMIT -1 CONNECTION LIMIT -1"),
+		Parses("ALTER DATABASE name WITH CONNECTION LIMIT -1 CONNECTION LIMIT -1"),
+		Parses("ALTER DATABASE name IS_TEMPLATE istemplate CONNECTION LIMIT -1"),
+		Parses("ALTER DATABASE name WITH IS_TEMPLATE istemplate CONNECTION LIMIT -1"),
+		Parses("ALTER DATABASE name ALLOW_CONNECTIONS allowconn IS_TEMPLATE istemplate"),
+		Parses("ALTER DATABASE name WITH ALLOW_CONNECTIONS allowconn IS_TEMPLATE istemplate"),
+		Parses("ALTER DATABASE name CONNECTION LIMIT -1 IS_TEMPLATE istemplate"),
+		Parses("ALTER DATABASE name WITH CONNECTION LIMIT -1 IS_TEMPLATE istemplate"),
+		Parses("ALTER DATABASE name IS_TEMPLATE istemplate IS_TEMPLATE istemplate"),
+		Parses("ALTER DATABASE name WITH IS_TEMPLATE istemplate IS_TEMPLATE istemplate"),
+		Parses("ALTER DATABASE name RENAME TO new_name"),
+		Converts("ALTER DATABASE name OWNER TO new_owner"),
+		Converts("ALTER DATABASE name OWNER TO CURRENT_ROLE"),
+		Converts("ALTER DATABASE name OWNER TO CURRENT_USER"),
+		Converts("ALTER DATABASE name OWNER TO SESSION_USER"),
+		Parses("ALTER DATABASE name SET TABLESPACE new_tablespace"),
+		Parses("ALTER DATABASE name REFRESH COLLATION VERSION"),
+		Parses("ALTER DATABASE name SET configuration_parameter TO value"),
+		Parses("ALTER DATABASE name SET configuration_parameter = value"),
+		Parses("ALTER DATABASE name SET configuration_parameter TO DEFAULT"),
+		Parses("ALTER DATABASE name SET configuration_parameter = DEFAULT"),
+		Parses("ALTER DATABASE name SET configuration_parameter FROM CURRENT"),
+		Parses("ALTER DATABASE name RESET configuration_parameter"),
+		Parses("ALTER DATABASE name RESET ALL"),
+	}
+
+	RunTests(t, tests)
+	// RewriteTests(t, tests, "alter_database_test.go")
+}

testing/generation/command_docs/output/alter_domain_test.go

@@ -0,0 +1,43 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterDomain(t *testing.T) {
+	tests := []QueryParses{
+		Parses("ALTER DOMAIN name SET DEFAULT expression"),
+		Parses("ALTER DOMAIN name DROP DEFAULT"),
+		Parses("ALTER DOMAIN name SET NOT NULL"),
+		Parses("ALTER DOMAIN name DROP NOT NULL"),
+		Parses("ALTER DOMAIN name ADD CONSTRAINT name CHECK ( condition )"),
+		Parses("ALTER DOMAIN name ADD CONSTRAINT name CHECK ( condition ) NOT VALID"),
+		Parses("ALTER DOMAIN name DROP CONSTRAINT constraint_name"),
+		Parses("ALTER DOMAIN name DROP CONSTRAINT IF EXISTS constraint_name"),
+		Parses("ALTER DOMAIN name DROP CONSTRAINT constraint_name RESTRICT"),
+		Parses("ALTER DOMAIN name DROP CONSTRAINT IF EXISTS constraint_name RESTRICT"),
+		Parses("ALTER DOMAIN name DROP CONSTRAINT constraint_name CASCADE"),
+		Parses("ALTER DOMAIN name DROP CONSTRAINT IF EXISTS constraint_name CASCADE"),
+		Parses("ALTER DOMAIN name RENAME CONSTRAINT constraint_name TO new_constraint_name"),
+		Parses("ALTER DOMAIN name VALIDATE CONSTRAINT constraint_name"),
+		Converts("ALTER DOMAIN name OWNER TO new_owner"),
+		Converts("ALTER DOMAIN name OWNER TO CURRENT_ROLE"),
+		Converts("ALTER DOMAIN name OWNER TO CURRENT_USER"),
+		Converts("ALTER DOMAIN name OWNER TO SESSION_USER"),
+		Parses("ALTER DOMAIN name RENAME TO new_name"),
+		Parses("ALTER DOMAIN name SET SCHEMA new_schema"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_event_trigger_test.go

@@ -0,0 +1,32 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterEventTrigger(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER EVENT TRIGGER name DISABLE"),
+		Unimplemented("ALTER EVENT TRIGGER name ENABLE"),
+		Unimplemented("ALTER EVENT TRIGGER name ENABLE REPLICA"),
+		Unimplemented("ALTER EVENT TRIGGER name ENABLE ALWAYS"),
+		Unimplemented("ALTER EVENT TRIGGER name OWNER TO new_owner"),
+		Unimplemented("ALTER EVENT TRIGGER name OWNER TO CURRENT_ROLE"),
+		Unimplemented("ALTER EVENT TRIGGER name OWNER TO CURRENT_USER"),
+		Unimplemented("ALTER EVENT TRIGGER name OWNER TO SESSION_USER"),
+		Unimplemented("ALTER EVENT TRIGGER name RENAME TO new_name"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_foreign_data_wrapper_test.go

@@ -0,0 +1,144 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterForeignDataWrapper(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function VALIDATOR validator_function"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER VALIDATOR validator_function"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function NO VALIDATOR"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER NO VALIDATOR"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function OPTIONS ( ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER OPTIONS ( ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function VALIDATOR validator_function OPTIONS ( ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER VALIDATOR validator_function OPTIONS ( ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function NO VALIDATOR OPTIONS ( ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER NO VALIDATOR OPTIONS ( ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function OPTIONS ( SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER OPTIONS ( SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function VALIDATOR validator_function OPTIONS ( SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER VALIDATOR validator_function OPTIONS ( SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function NO VALIDATOR OPTIONS ( SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER NO VALIDATOR OPTIONS ( SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function OPTIONS ( DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER OPTIONS ( DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function VALIDATOR validator_function OPTIONS ( DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER VALIDATOR validator_function OPTIONS ( DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function NO VALIDATOR OPTIONS ( DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER NO VALIDATOR OPTIONS ( DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function OPTIONS ( ADD option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER OPTIONS ( ADD option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function VALIDATOR validator_function OPTIONS ( ADD option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER VALIDATOR validator_function OPTIONS ( ADD option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function NO VALIDATOR OPTIONS ( ADD option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER NO VALIDATOR OPTIONS ( ADD option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function OPTIONS ( SET option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER OPTIONS ( SET option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function VALIDATOR validator_function OPTIONS ( SET option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER VALIDATOR validator_function OPTIONS ( SET option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function NO VALIDATOR OPTIONS ( SET option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER NO VALIDATOR OPTIONS ( SET option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function OPTIONS ( DROP option , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER OPTIONS ( DROP option , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function VALIDATOR validator_function OPTIONS ( DROP option , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER VALIDATOR validator_function OPTIONS ( DROP option , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function NO VALIDATOR OPTIONS ( DROP option , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER NO VALIDATOR OPTIONS ( DROP option , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function OPTIONS ( ADD option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER OPTIONS ( ADD option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function VALIDATOR validator_function OPTIONS ( ADD option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER VALIDATOR validator_function OPTIONS ( ADD option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function NO VALIDATOR OPTIONS ( ADD option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER NO VALIDATOR OPTIONS ( ADD option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function OPTIONS ( SET option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER OPTIONS ( SET option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function VALIDATOR validator_function OPTIONS ( SET option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER VALIDATOR validator_function OPTIONS ( SET option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function NO VALIDATOR OPTIONS ( SET option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER NO VALIDATOR OPTIONS ( SET option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function OPTIONS ( DROP option , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER OPTIONS ( DROP option , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function VALIDATOR validator_function OPTIONS ( DROP option , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER VALIDATOR validator_function OPTIONS ( DROP option , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function NO VALIDATOR OPTIONS ( DROP option , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER NO VALIDATOR OPTIONS ( DROP option , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function OPTIONS ( ADD option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER OPTIONS ( ADD option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function VALIDATOR validator_function OPTIONS ( ADD option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER VALIDATOR validator_function OPTIONS ( ADD option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function NO VALIDATOR OPTIONS ( ADD option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER NO VALIDATOR OPTIONS ( ADD option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function OPTIONS ( SET option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER OPTIONS ( SET option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function VALIDATOR validator_function OPTIONS ( SET option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER VALIDATOR validator_function OPTIONS ( SET option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function NO VALIDATOR OPTIONS ( SET option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER NO VALIDATOR OPTIONS ( SET option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function OPTIONS ( DROP option , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER OPTIONS ( DROP option , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function VALIDATOR validator_function OPTIONS ( DROP option , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER VALIDATOR validator_function OPTIONS ( DROP option , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name HANDLER handler_function NO VALIDATOR OPTIONS ( DROP option , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO HANDLER NO VALIDATOR OPTIONS ( DROP option , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name VALIDATOR validator_function"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO VALIDATOR"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name VALIDATOR validator_function OPTIONS ( ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO VALIDATOR OPTIONS ( ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name VALIDATOR validator_function OPTIONS ( SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO VALIDATOR OPTIONS ( SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name VALIDATOR validator_function OPTIONS ( DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO VALIDATOR OPTIONS ( DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name VALIDATOR validator_function OPTIONS ( ADD option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO VALIDATOR OPTIONS ( ADD option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name VALIDATOR validator_function OPTIONS ( SET option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO VALIDATOR OPTIONS ( SET option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name VALIDATOR validator_function OPTIONS ( DROP option , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO VALIDATOR OPTIONS ( DROP option , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name VALIDATOR validator_function OPTIONS ( ADD option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO VALIDATOR OPTIONS ( ADD option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name VALIDATOR validator_function OPTIONS ( SET option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO VALIDATOR OPTIONS ( SET option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name VALIDATOR validator_function OPTIONS ( DROP option , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO VALIDATOR OPTIONS ( DROP option , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name VALIDATOR validator_function OPTIONS ( ADD option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO VALIDATOR OPTIONS ( ADD option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name VALIDATOR validator_function OPTIONS ( SET option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO VALIDATOR OPTIONS ( SET option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name VALIDATOR validator_function OPTIONS ( DROP option , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name NO VALIDATOR OPTIONS ( DROP option , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name OPTIONS ( ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name OPTIONS ( SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name OPTIONS ( DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name OPTIONS ( ADD option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name OPTIONS ( SET option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name OPTIONS ( DROP option , ADD option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name OPTIONS ( ADD option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name OPTIONS ( SET option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name OPTIONS ( DROP option , SET option ' value ' )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name OPTIONS ( ADD option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name OPTIONS ( SET option ' value ' , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name OPTIONS ( DROP option , DROP option )"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name OWNER TO new_owner"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name OWNER TO CURRENT_ROLE"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name OWNER TO CURRENT_USER"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name OWNER TO SESSION_USER"),
+		Unimplemented("ALTER FOREIGN DATA WRAPPER name RENAME TO new_name"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_group_test.go

@@ -0,0 +1,40 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterGroup(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER GROUP role_name ADD USER user_name"),
+		Unimplemented("ALTER GROUP CURRENT_ROLE ADD USER user_name"),
+		Unimplemented("ALTER GROUP CURRENT_USER ADD USER user_name"),
+		Unimplemented("ALTER GROUP SESSION_USER ADD USER user_name"),
+		Unimplemented("ALTER GROUP role_name ADD USER user_name , user_name"),
+		Unimplemented("ALTER GROUP CURRENT_ROLE ADD USER user_name , user_name"),
+		Unimplemented("ALTER GROUP CURRENT_USER ADD USER user_name , user_name"),
+		Unimplemented("ALTER GROUP SESSION_USER ADD USER user_name , user_name"),
+		Unimplemented("ALTER GROUP role_name DROP USER user_name"),
+		Unimplemented("ALTER GROUP CURRENT_ROLE DROP USER user_name"),
+		Unimplemented("ALTER GROUP CURRENT_USER DROP USER user_name"),
+		Unimplemented("ALTER GROUP SESSION_USER DROP USER user_name"),
+		Unimplemented("ALTER GROUP role_name DROP USER user_name , user_name"),
+		Unimplemented("ALTER GROUP CURRENT_ROLE DROP USER user_name , user_name"),
+		Unimplemented("ALTER GROUP CURRENT_USER DROP USER user_name , user_name"),
+		Unimplemented("ALTER GROUP SESSION_USER DROP USER user_name , user_name"),
+		Unimplemented("ALTER GROUP group_name RENAME TO new_name"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_index_test.go

@@ -0,0 +1,58 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterIndex(t *testing.T) {
+	tests := []QueryParses{
+		Parses("ALTER INDEX name RENAME TO new_name"),
+		Parses("ALTER INDEX IF EXISTS name RENAME TO new_name"),
+		Parses("ALTER INDEX name SET TABLESPACE tablespace_name"),
+		Parses("ALTER INDEX IF EXISTS name SET TABLESPACE tablespace_name"),
+		Parses("ALTER INDEX name ATTACH PARTITION index_name"),
+		Parses("ALTER INDEX name DEPENDS ON EXTENSION extension_name"),
+		Parses("ALTER INDEX name NO DEPENDS ON EXTENSION extension_name"),
+		Parses("ALTER INDEX name SET ( fillfactor )"),
+		Parses("ALTER INDEX IF EXISTS name SET ( fillfactor )"),
+		Parses("ALTER INDEX name SET ( fillfactor = value )"),
+		Parses("ALTER INDEX IF EXISTS name SET ( fillfactor = value )"),
+		Parses("ALTER INDEX name SET ( fillfactor , fillfactor )"),
+		Parses("ALTER INDEX IF EXISTS name SET ( fillfactor , fillfactor )"),
+		Parses("ALTER INDEX name SET ( fillfactor = value , fillfactor )"),
+		Parses("ALTER INDEX IF EXISTS name SET ( fillfactor = value , fillfactor )"),
+		Parses("ALTER INDEX name SET ( fillfactor , fillfactor = value )"),
+		Parses("ALTER INDEX IF EXISTS name SET ( fillfactor , fillfactor = value )"),
+		Parses("ALTER INDEX name SET ( fillfactor = value , fillfactor = value )"),
+		Parses("ALTER INDEX IF EXISTS name SET ( fillfactor = value , fillfactor = value )"),
+		Parses("ALTER INDEX name RESET ( fillfactor )"),
+		Parses("ALTER INDEX IF EXISTS name RESET ( fillfactor )"),
+		Parses("ALTER INDEX name RESET ( fillfactor , fillfactor )"),
+		Parses("ALTER INDEX IF EXISTS name RESET ( fillfactor , fillfactor )"),
+		Parses("ALTER INDEX name ALTER 1 SET STATISTICS 1"),
+		Parses("ALTER INDEX IF EXISTS name ALTER 1 SET STATISTICS 1"),
+		Parses("ALTER INDEX name ALTER COLUMN 1 SET STATISTICS 1"),
+		Parses("ALTER INDEX IF EXISTS name ALTER COLUMN 1 SET STATISTICS 1"),
+		Parses("ALTER INDEX ALL IN TABLESPACE name SET TABLESPACE new_tablespace"),
+		Parses("ALTER INDEX ALL IN TABLESPACE name OWNED BY role_name SET TABLESPACE new_tablespace"),
+		Parses("ALTER INDEX ALL IN TABLESPACE name OWNED BY role_name , role_name SET TABLESPACE new_tablespace"),
+		Parses("ALTER INDEX ALL IN TABLESPACE name SET TABLESPACE new_tablespace NOWAIT"),
+		Parses("ALTER INDEX ALL IN TABLESPACE name OWNED BY role_name SET TABLESPACE new_tablespace NOWAIT"),
+		Parses("ALTER INDEX ALL IN TABLESPACE name OWNED BY role_name , role_name SET TABLESPACE new_tablespace NOWAIT"),
+	}
+
+	RunTests(t, tests)
+	// RewriteTests(t, tests, "alter_index_test.go")
+}

testing/generation/command_docs/output/alter_language_test.go

@@ -0,0 +1,33 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterLanguage(t *testing.T) {
+	tests := []QueryParses{
+		Parses("ALTER LANGUAGE name RENAME TO new_name"),
+		Parses("ALTER PROCEDURAL LANGUAGE name RENAME TO new_name"),
+		Parses("ALTER LANGUAGE name OWNER TO new_owner"),
+		Parses("ALTER PROCEDURAL LANGUAGE name OWNER TO new_owner"),
+		Parses("ALTER LANGUAGE name OWNER TO CURRENT_ROLE"),
+		Parses("ALTER PROCEDURAL LANGUAGE name OWNER TO CURRENT_ROLE"),
+		Parses("ALTER LANGUAGE name OWNER TO CURRENT_USER"),
+		Parses("ALTER PROCEDURAL LANGUAGE name OWNER TO CURRENT_USER"),
+		Parses("ALTER LANGUAGE name OWNER TO SESSION_USER"),
+		Parses("ALTER PROCEDURAL LANGUAGE name OWNER TO SESSION_USER"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_large_object_test.go

@@ -0,0 +1,27 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterLargeObject(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER LARGE OBJECT 99999 OWNER TO new_owner"),
+		Unimplemented("ALTER LARGE OBJECT 99999 OWNER TO CURRENT_ROLE"),
+		Unimplemented("ALTER LARGE OBJECT 99999 OWNER TO CURRENT_USER"),
+		Unimplemented("ALTER LARGE OBJECT 99999 OWNER TO SESSION_USER"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_operator_class_test.go

@@ -0,0 +1,29 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterOperatorClass(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER OPERATOR CLASS name USING index_method RENAME TO new_name"),
+		Unimplemented("ALTER OPERATOR CLASS name USING index_method OWNER TO new_owner"),
+		Unimplemented("ALTER OPERATOR CLASS name USING index_method OWNER TO CURRENT_ROLE"),
+		Unimplemented("ALTER OPERATOR CLASS name USING index_method OWNER TO CURRENT_USER"),
+		Unimplemented("ALTER OPERATOR CLASS name USING index_method OWNER TO SESSION_USER"),
+		Unimplemented("ALTER OPERATOR CLASS name USING index_method SET SCHEMA new_schema"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_operator_family_test.go

@@ -0,0 +1,205 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterOperatorFamily(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name , FUNCTION 3 function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name , FUNCTION 3 function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name , FUNCTION 3 function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name , FUNCTION 3 ( op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name , FUNCTION 3 ( op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name , FUNCTION 3 ( op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type , op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name , FUNCTION 3 ( op_type , op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name , FUNCTION 3 ( op_type , op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name , FUNCTION 3 ( op_type , op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method ADD FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP OPERATOR 3 ( op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP OPERATOR 3 ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP FUNCTION 3 ( op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP FUNCTION 3 ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP OPERATOR 3 ( op_type ) , OPERATOR 3 ( op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP OPERATOR 3 ( op_type , op_type ) , OPERATOR 3 ( op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP FUNCTION 3 ( op_type ) , OPERATOR 3 ( op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP FUNCTION 3 ( op_type , op_type ) , OPERATOR 3 ( op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP OPERATOR 3 ( op_type ) , OPERATOR 3 ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP OPERATOR 3 ( op_type , op_type ) , OPERATOR 3 ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP FUNCTION 3 ( op_type ) , OPERATOR 3 ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP FUNCTION 3 ( op_type , op_type ) , OPERATOR 3 ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP OPERATOR 3 ( op_type ) , FUNCTION 3 ( op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP OPERATOR 3 ( op_type , op_type ) , FUNCTION 3 ( op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP FUNCTION 3 ( op_type ) , FUNCTION 3 ( op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP FUNCTION 3 ( op_type , op_type ) , FUNCTION 3 ( op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP OPERATOR 3 ( op_type ) , FUNCTION 3 ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP OPERATOR 3 ( op_type , op_type ) , FUNCTION 3 ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP FUNCTION 3 ( op_type ) , FUNCTION 3 ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method DROP FUNCTION 3 ( op_type , op_type ) , FUNCTION 3 ( op_type , op_type )"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method RENAME TO new_name"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method OWNER TO new_owner"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method OWNER TO CURRENT_ROLE"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method OWNER TO CURRENT_USER"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method OWNER TO SESSION_USER"),
+		Unimplemented("ALTER OPERATOR FAMILY name USING index_method SET SCHEMA new_schema"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_operator_test.go

@@ -0,0 +1,73 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterOperator(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) OWNER TO new_owner"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) OWNER TO new_owner"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) OWNER TO CURRENT_ROLE"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) OWNER TO CURRENT_ROLE"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) OWNER TO CURRENT_USER"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) OWNER TO CURRENT_USER"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) OWNER TO SESSION_USER"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) OWNER TO SESSION_USER"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET SCHEMA new_schema"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET SCHEMA new_schema"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( RESTRICT = res_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( RESTRICT = res_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( RESTRICT = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( RESTRICT = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( JOIN = join_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( JOIN = join_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( JOIN = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( JOIN = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( RESTRICT = res_proc , RESTRICT = res_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( RESTRICT = res_proc , RESTRICT = res_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( RESTRICT = NONE , RESTRICT = res_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( RESTRICT = NONE , RESTRICT = res_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( JOIN = join_proc , RESTRICT = res_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( JOIN = join_proc , RESTRICT = res_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( JOIN = NONE , RESTRICT = res_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( JOIN = NONE , RESTRICT = res_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( RESTRICT = res_proc , RESTRICT = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( RESTRICT = res_proc , RESTRICT = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( RESTRICT = NONE , RESTRICT = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( RESTRICT = NONE , RESTRICT = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( JOIN = join_proc , RESTRICT = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( JOIN = join_proc , RESTRICT = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( JOIN = NONE , RESTRICT = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( JOIN = NONE , RESTRICT = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( RESTRICT = NONE , JOIN = join_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( RESTRICT = NONE , JOIN = join_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( JOIN = join_proc , JOIN = join_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( JOIN = join_proc , JOIN = join_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( JOIN = NONE , JOIN = join_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( JOIN = NONE , JOIN = join_proc )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( RESTRICT = res_proc , JOIN = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( RESTRICT = res_proc , JOIN = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( RESTRICT = NONE , JOIN = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( RESTRICT = NONE , JOIN = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( JOIN = join_proc , JOIN = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( JOIN = join_proc , JOIN = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( left_type , right_type ) SET ( JOIN = NONE , JOIN = NONE )"),
+		Unimplemented("ALTER OPERATOR @@ ( NONE , right_type ) SET ( JOIN = NONE , JOIN = NONE )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_policy_test.go

@@ -0,0 +1,148 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterPolicy(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER POLICY name ON table_name RENAME TO new_name"),
+		Unimplemented("ALTER POLICY name ON table_name"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , role_name"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , role_name"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , role_name"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , role_name"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , role_name"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , PUBLIC"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , PUBLIC"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , PUBLIC"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , PUBLIC"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , PUBLIC"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , CURRENT_ROLE"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , CURRENT_ROLE"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , CURRENT_ROLE"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , CURRENT_ROLE"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , CURRENT_ROLE"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , CURRENT_USER"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , CURRENT_USER"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , CURRENT_USER"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , CURRENT_USER"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , CURRENT_USER"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , SESSION_USER"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , SESSION_USER"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , SESSION_USER"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , SESSION_USER"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , SESSION_USER"),
+		Unimplemented("ALTER POLICY name ON table_name USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , role_name USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , role_name USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , role_name USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , role_name USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , role_name USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , PUBLIC USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , PUBLIC USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , PUBLIC USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , PUBLIC USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , PUBLIC USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , CURRENT_ROLE USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , CURRENT_ROLE USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , CURRENT_ROLE USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , CURRENT_ROLE USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , CURRENT_ROLE USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , CURRENT_USER USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , CURRENT_USER USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , CURRENT_USER USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , CURRENT_USER USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , CURRENT_USER USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , SESSION_USER USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , SESSION_USER USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , SESSION_USER USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , SESSION_USER USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , SESSION_USER USING ( using_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , role_name WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , role_name WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , role_name WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , role_name WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , role_name WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , PUBLIC WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , PUBLIC WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , PUBLIC WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , PUBLIC WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , PUBLIC WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , CURRENT_ROLE WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , CURRENT_ROLE WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , CURRENT_ROLE WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , CURRENT_ROLE WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , CURRENT_ROLE WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , CURRENT_USER WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , CURRENT_USER WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , CURRENT_USER WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , CURRENT_USER WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , CURRENT_USER WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , SESSION_USER WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , SESSION_USER WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , SESSION_USER WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , SESSION_USER WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , SESSION_USER WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , role_name USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , role_name USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , role_name USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , role_name USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , role_name USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , PUBLIC USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , PUBLIC USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , PUBLIC USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , PUBLIC USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , PUBLIC USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , CURRENT_ROLE USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , CURRENT_ROLE USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , CURRENT_ROLE USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , CURRENT_ROLE USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , CURRENT_ROLE USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , CURRENT_USER USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , CURRENT_USER USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , CURRENT_USER USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , CURRENT_USER USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , CURRENT_USER USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO role_name , SESSION_USER USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO PUBLIC , SESSION_USER USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_ROLE , SESSION_USER USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO CURRENT_USER , SESSION_USER USING ( using_expression ) WITH CHECK ( check_expression )"),
+		Unimplemented("ALTER POLICY name ON table_name TO SESSION_USER , SESSION_USER USING ( using_expression ) WITH CHECK ( check_expression )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_rule_test.go

@@ -0,0 +1,24 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterRule(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER RULE name ON table_name RENAME TO new_name"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_schema_test.go

@@ -0,0 +1,28 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterSchema(t *testing.T) {
+	tests := []QueryParses{
+		Parses("ALTER SCHEMA name RENAME TO new_name"),
+		Converts("ALTER SCHEMA name OWNER TO new_owner"),
+		Converts("ALTER SCHEMA name OWNER TO CURRENT_ROLE"),
+		Converts("ALTER SCHEMA name OWNER TO CURRENT_USER"),
+		Converts("ALTER SCHEMA name OWNER TO SESSION_USER"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_server_test.go

@@ -0,0 +1,55 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterServer(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER SERVER name VERSION ' new_version '"),
+		Unimplemented("ALTER SERVER name VERSION ' new_version ' OPTIONS ( ADD option ' value ' )"),
+		Unimplemented("ALTER SERVER name VERSION ' new_version ' OPTIONS ( SET option ' value ' )"),
+		Unimplemented("ALTER SERVER name VERSION ' new_version ' OPTIONS ( DROP option )"),
+		Unimplemented("ALTER SERVER name VERSION ' new_version ' OPTIONS ( ADD option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER SERVER name VERSION ' new_version ' OPTIONS ( SET option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER SERVER name VERSION ' new_version ' OPTIONS ( DROP option , ADD option ' value ' )"),
+		Unimplemented("ALTER SERVER name VERSION ' new_version ' OPTIONS ( ADD option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER SERVER name VERSION ' new_version ' OPTIONS ( SET option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER SERVER name VERSION ' new_version ' OPTIONS ( DROP option , SET option ' value ' )"),
+		Unimplemented("ALTER SERVER name VERSION ' new_version ' OPTIONS ( ADD option ' value ' , DROP option )"),
+		Unimplemented("ALTER SERVER name VERSION ' new_version ' OPTIONS ( SET option ' value ' , DROP option )"),
+		Unimplemented("ALTER SERVER name VERSION ' new_version ' OPTIONS ( DROP option , DROP option )"),
+		Unimplemented("ALTER SERVER name OPTIONS ( ADD option ' value ' )"),
+		Unimplemented("ALTER SERVER name OPTIONS ( SET option ' value ' )"),
+		Unimplemented("ALTER SERVER name OPTIONS ( DROP option )"),
+		Unimplemented("ALTER SERVER name OPTIONS ( ADD option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER SERVER name OPTIONS ( SET option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER SERVER name OPTIONS ( DROP option , ADD option ' value ' )"),
+		Unimplemented("ALTER SERVER name OPTIONS ( ADD option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER SERVER name OPTIONS ( SET option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER SERVER name OPTIONS ( DROP option , SET option ' value ' )"),
+		Unimplemented("ALTER SERVER name OPTIONS ( ADD option ' value ' , DROP option )"),
+		Unimplemented("ALTER SERVER name OPTIONS ( SET option ' value ' , DROP option )"),
+		Unimplemented("ALTER SERVER name OPTIONS ( DROP option , DROP option )"),
+		Unimplemented("ALTER SERVER name OWNER TO new_owner"),
+		Unimplemented("ALTER SERVER name OWNER TO CURRENT_ROLE"),
+		Unimplemented("ALTER SERVER name OWNER TO CURRENT_USER"),
+		Unimplemented("ALTER SERVER name OWNER TO SESSION_USER"),
+		Unimplemented("ALTER SERVER name RENAME TO new_name"),
+	}
+
+	//RunTests(t, tests)
+	RewriteTests(t, tests, "alter_server_test.go")
+}

testing/generation/command_docs/output/alter_statistics_test.go

@@ -0,0 +1,30 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterStatistics(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER STATISTICS name OWNER TO new_owner"),
+		Unimplemented("ALTER STATISTICS name OWNER TO CURRENT_ROLE"),
+		Unimplemented("ALTER STATISTICS name OWNER TO CURRENT_USER"),
+		Unimplemented("ALTER STATISTICS name OWNER TO SESSION_USER"),
+		Unimplemented("ALTER STATISTICS name RENAME TO new_name"),
+		Unimplemented("ALTER STATISTICS name SET SCHEMA new_schema"),
+		Unimplemented("ALTER STATISTICS name SET STATISTICS 1"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_subscription_test.go

@@ -0,0 +1,87 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterSubscription(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER SUBSCRIPTION name CONNECTION ' conninfo '"),
+		Unimplemented("ALTER SUBSCRIPTION name SET PUBLICATION publication_name"),
+		Unimplemented("ALTER SUBSCRIPTION name SET PUBLICATION publication_name , publication_name"),
+		Unimplemented("ALTER SUBSCRIPTION name SET PUBLICATION publication_name WITH ( publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name SET PUBLICATION publication_name , publication_name WITH ( publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name SET PUBLICATION publication_name WITH ( publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name SET PUBLICATION publication_name , publication_name WITH ( publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name SET PUBLICATION publication_name WITH ( publication_option , publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name SET PUBLICATION publication_name , publication_name WITH ( publication_option , publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name SET PUBLICATION publication_name WITH ( publication_option = value , publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name SET PUBLICATION publication_name , publication_name WITH ( publication_option = value , publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name SET PUBLICATION publication_name WITH ( publication_option , publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name SET PUBLICATION publication_name , publication_name WITH ( publication_option , publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name SET PUBLICATION publication_name WITH ( publication_option = value , publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name SET PUBLICATION publication_name , publication_name WITH ( publication_option = value , publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name ADD PUBLICATION publication_name"),
+		Unimplemented("ALTER SUBSCRIPTION name ADD PUBLICATION publication_name , publication_name"),
+		Unimplemented("ALTER SUBSCRIPTION name ADD PUBLICATION publication_name WITH ( publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name ADD PUBLICATION publication_name , publication_name WITH ( publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name ADD PUBLICATION publication_name WITH ( publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name ADD PUBLICATION publication_name , publication_name WITH ( publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name ADD PUBLICATION publication_name WITH ( publication_option , publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name ADD PUBLICATION publication_name , publication_name WITH ( publication_option , publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name ADD PUBLICATION publication_name WITH ( publication_option = value , publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name ADD PUBLICATION publication_name , publication_name WITH ( publication_option = value , publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name ADD PUBLICATION publication_name WITH ( publication_option , publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name ADD PUBLICATION publication_name , publication_name WITH ( publication_option , publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name ADD PUBLICATION publication_name WITH ( publication_option = value , publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name ADD PUBLICATION publication_name , publication_name WITH ( publication_option = value , publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name DROP PUBLICATION publication_name"),
+		Unimplemented("ALTER SUBSCRIPTION name DROP PUBLICATION publication_name , publication_name"),
+		Unimplemented("ALTER SUBSCRIPTION name DROP PUBLICATION publication_name WITH ( publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name DROP PUBLICATION publication_name , publication_name WITH ( publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name DROP PUBLICATION publication_name WITH ( publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name DROP PUBLICATION publication_name , publication_name WITH ( publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name DROP PUBLICATION publication_name WITH ( publication_option , publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name DROP PUBLICATION publication_name , publication_name WITH ( publication_option , publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name DROP PUBLICATION publication_name WITH ( publication_option = value , publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name DROP PUBLICATION publication_name , publication_name WITH ( publication_option = value , publication_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name DROP PUBLICATION publication_name WITH ( publication_option , publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name DROP PUBLICATION publication_name , publication_name WITH ( publication_option , publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name DROP PUBLICATION publication_name WITH ( publication_option = value , publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name DROP PUBLICATION publication_name , publication_name WITH ( publication_option = value , publication_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name REFRESH PUBLICATION"),
+		Unimplemented("ALTER SUBSCRIPTION name REFRESH PUBLICATION WITH ( refresh_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name REFRESH PUBLICATION WITH ( refresh_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name REFRESH PUBLICATION WITH ( refresh_option , refresh_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name REFRESH PUBLICATION WITH ( refresh_option = value , refresh_option )"),
+		Unimplemented("ALTER SUBSCRIPTION name REFRESH PUBLICATION WITH ( refresh_option , refresh_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name REFRESH PUBLICATION WITH ( refresh_option = value , refresh_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name ENABLE"),
+		Unimplemented("ALTER SUBSCRIPTION name DISABLE"),
+		Unimplemented("ALTER SUBSCRIPTION name SET ( subscription_parameter )"),
+		Unimplemented("ALTER SUBSCRIPTION name SET ( subscription_parameter = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name SET ( subscription_parameter , subscription_parameter )"),
+		Unimplemented("ALTER SUBSCRIPTION name SET ( subscription_parameter = value , subscription_parameter )"),
+		Unimplemented("ALTER SUBSCRIPTION name SET ( subscription_parameter , subscription_parameter = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name SET ( subscription_parameter = value , subscription_parameter = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name SKIP ( skip_option = value )"),
+		Unimplemented("ALTER SUBSCRIPTION name OWNER TO new_owner"),
+		Unimplemented("ALTER SUBSCRIPTION name OWNER TO CURRENT_ROLE"),
+		Unimplemented("ALTER SUBSCRIPTION name OWNER TO CURRENT_USER"),
+		Unimplemented("ALTER SUBSCRIPTION name OWNER TO SESSION_USER"),
+		Unimplemented("ALTER SUBSCRIPTION name RENAME TO new_name"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_system_test.go

@@ -0,0 +1,31 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterSystem(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER SYSTEM SET configuration_parameter TO value"),
+		Unimplemented("ALTER SYSTEM SET configuration_parameter = value"),
+		Unimplemented("ALTER SYSTEM SET configuration_parameter TO value , value"),
+		Unimplemented("ALTER SYSTEM SET configuration_parameter = value , value"),
+		Unimplemented("ALTER SYSTEM SET configuration_parameter TO DEFAULT"),
+		Unimplemented("ALTER SYSTEM SET configuration_parameter = DEFAULT"),
+		Unimplemented("ALTER SYSTEM RESET configuration_parameter"),
+		Unimplemented("ALTER SYSTEM RESET ALL"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_tablespace_test.go

@@ -0,0 +1,32 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterTablespace(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER TABLESPACE name RENAME TO new_name"),
+		Unimplemented("ALTER TABLESPACE name OWNER TO new_owner"),
+		Unimplemented("ALTER TABLESPACE name OWNER TO CURRENT_ROLE"),
+		Unimplemented("ALTER TABLESPACE name OWNER TO CURRENT_USER"),
+		Unimplemented("ALTER TABLESPACE name OWNER TO SESSION_USER"),
+		Unimplemented("ALTER TABLESPACE name SET ( tablespace_option = value )"),
+		Unimplemented("ALTER TABLESPACE name SET ( tablespace_option = value , value )"),
+		Unimplemented("ALTER TABLESPACE name RESET ( tablespace_option )"),
+		Unimplemented("ALTER TABLESPACE name RESET ( tablespace_option , tablespace_option )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_text_search_configuration_test.go

@@ -0,0 +1,44 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterTextSearchConfiguration(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name ADD MAPPING FOR token_type WITH dictionary_name"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name ADD MAPPING FOR token_type , token_type WITH dictionary_name"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name ADD MAPPING FOR token_type WITH dictionary_name , dictionary_name"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name ADD MAPPING FOR token_type , token_type WITH dictionary_name , dictionary_name"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name ALTER MAPPING FOR token_type WITH dictionary_name"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name ALTER MAPPING FOR token_type , token_type WITH dictionary_name"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name ALTER MAPPING FOR token_type WITH dictionary_name , dictionary_name"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name ALTER MAPPING FOR token_type , token_type WITH dictionary_name , dictionary_name"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name ALTER MAPPING REPLACE old_dictionary WITH new_dictionary"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name ALTER MAPPING FOR token_type REPLACE old_dictionary WITH new_dictionary"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name ALTER MAPPING FOR token_type , token_type REPLACE old_dictionary WITH new_dictionary"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name DROP MAPPING FOR token_type"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name DROP MAPPING IF EXISTS FOR token_type"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name DROP MAPPING FOR token_type , token_type"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name DROP MAPPING IF EXISTS FOR token_type , token_type"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name RENAME TO new_name"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name OWNER TO new_owner"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name OWNER TO CURRENT_ROLE"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name OWNER TO CURRENT_USER"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name OWNER TO SESSION_USER"),
+		Unimplemented("ALTER TEXT SEARCH CONFIGURATION name SET SCHEMA new_schema"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_text_search_dictionary_test.go

@@ -0,0 +1,35 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterTextSearchDictionary(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER TEXT SEARCH DICTIONARY name ( option )"),
+		Unimplemented("ALTER TEXT SEARCH DICTIONARY name ( option = value )"),
+		Unimplemented("ALTER TEXT SEARCH DICTIONARY name ( option , option )"),
+		Unimplemented("ALTER TEXT SEARCH DICTIONARY name ( option = value , option )"),
+		Unimplemented("ALTER TEXT SEARCH DICTIONARY name ( option , option = value )"),
+		Unimplemented("ALTER TEXT SEARCH DICTIONARY name ( option = value , option = value )"),
+		Unimplemented("ALTER TEXT SEARCH DICTIONARY name RENAME TO new_name"),
+		Unimplemented("ALTER TEXT SEARCH DICTIONARY name OWNER TO new_owner"),
+		Unimplemented("ALTER TEXT SEARCH DICTIONARY name OWNER TO CURRENT_ROLE"),
+		Unimplemented("ALTER TEXT SEARCH DICTIONARY name OWNER TO CURRENT_USER"),
+		Unimplemented("ALTER TEXT SEARCH DICTIONARY name OWNER TO SESSION_USER"),
+		Unimplemented("ALTER TEXT SEARCH DICTIONARY name SET SCHEMA new_schema"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_text_search_parser_test.go

@@ -0,0 +1,25 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterTextSearchParser(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER TEXT SEARCH PARSER name RENAME TO new_name"),
+		Unimplemented("ALTER TEXT SEARCH PARSER name SET SCHEMA new_schema"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_text_search_template_test.go

@@ -0,0 +1,25 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterTextSearchTemplate(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER TEXT SEARCH TEMPLATE name RENAME TO new_name"),
+		Unimplemented("ALTER TEXT SEARCH TEMPLATE name SET SCHEMA new_schema"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_trigger_test.go

@@ -0,0 +1,26 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterTrigger(t *testing.T) {
+	tests := []QueryParses{
+		Parses("ALTER TRIGGER name ON table_name RENAME TO new_name"),
+		Parses("ALTER TRIGGER name ON table_name DEPENDS ON EXTENSION extension_name"),
+		Parses("ALTER TRIGGER name ON table_name NO DEPENDS ON EXTENSION extension_name"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_type_test.go

@@ -0,0 +1,683 @@
+// Copyright 2024 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterType(t *testing.T) {
+	tests := []QueryParses{
+		Converts("ALTER TYPE name OWNER TO new_owner"),
+		Converts("ALTER TYPE name OWNER TO CURRENT_ROLE"),
+		Converts("ALTER TYPE name OWNER TO CURRENT_USER"),
+		Converts("ALTER TYPE name OWNER TO SESSION_USER"),
+		Parses("ALTER TYPE name RENAME TO new_name"),
+		Parses("ALTER TYPE name SET SCHEMA new_schema"),
+		Parses("ALTER TYPE name RENAME ATTRIBUTE attribute_name TO new_attribute_name"),
+		Parses("ALTER TYPE name RENAME ATTRIBUTE attribute_name TO new_attribute_name CASCADE"),
+		Parses("ALTER TYPE name RENAME ATTRIBUTE attribute_name TO new_attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE attribute_name"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE attribute_name CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name DROP ATTRIBUTE IF EXISTS attribute_name RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US CASCADE , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT , ALTER ATTRIBUTE attribute_name SET DATA TYPE data_type COLLATE en_US RESTRICT"),
+		Parses("ALTER TYPE name ADD VALUE '1'"),
+		Parses("ALTER TYPE name ADD VALUE IF NOT EXISTS '1'"),
+		Parses("ALTER TYPE name ADD VALUE '1' BEFORE '1'"),
+		Parses("ALTER TYPE name ADD VALUE IF NOT EXISTS '1' BEFORE '1'"),
+		Parses("ALTER TYPE name ADD VALUE '1' AFTER '1'"),
+		Parses("ALTER TYPE name ADD VALUE IF NOT EXISTS '1' AFTER '1'"),
+		Parses("ALTER TYPE name RENAME VALUE '1' TO '1'"),
+		Parses("ALTER TYPE name SET ( RECEIVE = receive_function )"),
+		Parses("ALTER TYPE name SET ( SEND = send_function )"),
+		Parses("ALTER TYPE name SET ( TYPMOD_IN = type_modifier_input_function )"),
+		Parses("ALTER TYPE name SET ( TYPMOD_OUT = type_modifier_output_function )"),
+		Parses("ALTER TYPE name SET ( ANALYZE = analyze_function )"),
+		Parses("ALTER TYPE name SET ( SUBSCRIPT = subscript_function )"),
+		Parses("ALTER TYPE name SET ( RECEIVE = receive_function , RECEIVE = receive_function )"),
+		Parses("ALTER TYPE name SET ( SEND = send_function , RECEIVE = receive_function )"),
+		Parses("ALTER TYPE name SET ( TYPMOD_IN = type_modifier_input_function , RECEIVE = receive_function )"),
+		Parses("ALTER TYPE name SET ( TYPMOD_OUT = type_modifier_output_function , RECEIVE = receive_function )"),
+		Parses("ALTER TYPE name SET ( ANALYZE = analyze_function , RECEIVE = receive_function )"),
+		Parses("ALTER TYPE name SET ( SUBSCRIPT = subscript_function , RECEIVE = receive_function )"),
+		Parses("ALTER TYPE name SET ( RECEIVE = receive_function , SEND = send_function )"),
+		Parses("ALTER TYPE name SET ( SEND = send_function , SEND = send_function )"),
+		Parses("ALTER TYPE name SET ( TYPMOD_IN = type_modifier_input_function , SEND = send_function )"),
+		Parses("ALTER TYPE name SET ( TYPMOD_OUT = type_modifier_output_function , SEND = send_function )"),
+		Parses("ALTER TYPE name SET ( ANALYZE = analyze_function , SEND = send_function )"),
+		Parses("ALTER TYPE name SET ( SUBSCRIPT = subscript_function , SEND = send_function )"),
+		Parses("ALTER TYPE name SET ( RECEIVE = receive_function , TYPMOD_IN = type_modifier_input_function )"),
+		Parses("ALTER TYPE name SET ( SEND = send_function , TYPMOD_IN = type_modifier_input_function )"),
+		Parses("ALTER TYPE name SET ( TYPMOD_IN = type_modifier_input_function , TYPMOD_IN = type_modifier_input_function )"),
+		Parses("ALTER TYPE name SET ( TYPMOD_OUT = type_modifier_output_function , TYPMOD_IN = type_modifier_input_function )"),
+		Parses("ALTER TYPE name SET ( ANALYZE = analyze_function , TYPMOD_IN = type_modifier_input_function )"),
+		Parses("ALTER TYPE name SET ( SUBSCRIPT = subscript_function , TYPMOD_IN = type_modifier_input_function )"),
+		Parses("ALTER TYPE name SET ( RECEIVE = receive_function , TYPMOD_OUT = type_modifier_output_function )"),
+		Parses("ALTER TYPE name SET ( SEND = send_function , TYPMOD_OUT = type_modifier_output_function )"),
+		Parses("ALTER TYPE name SET ( TYPMOD_IN = type_modifier_input_function , TYPMOD_OUT = type_modifier_output_function )"),
+		Parses("ALTER TYPE name SET ( TYPMOD_OUT = type_modifier_output_function , TYPMOD_OUT = type_modifier_output_function )"),
+		Parses("ALTER TYPE name SET ( ANALYZE = analyze_function , TYPMOD_OUT = type_modifier_output_function )"),
+		Parses("ALTER TYPE name SET ( SUBSCRIPT = subscript_function , TYPMOD_OUT = type_modifier_output_function )"),
+		Parses("ALTER TYPE name SET ( RECEIVE = receive_function , ANALYZE = analyze_function )"),
+		Parses("ALTER TYPE name SET ( SEND = send_function , ANALYZE = analyze_function )"),
+		Parses("ALTER TYPE name SET ( TYPMOD_IN = type_modifier_input_function , ANALYZE = analyze_function )"),
+		Parses("ALTER TYPE name SET ( TYPMOD_OUT = type_modifier_output_function , ANALYZE = analyze_function )"),
+		Parses("ALTER TYPE name SET ( ANALYZE = analyze_function , ANALYZE = analyze_function )"),
+		Parses("ALTER TYPE name SET ( SUBSCRIPT = subscript_function , ANALYZE = analyze_function )"),
+		Parses("ALTER TYPE name SET ( RECEIVE = receive_function , SUBSCRIPT = subscript_function )"),
+		Parses("ALTER TYPE name SET ( SEND = send_function , SUBSCRIPT = subscript_function )"),
+		Parses("ALTER TYPE name SET ( TYPMOD_IN = type_modifier_input_function , SUBSCRIPT = subscript_function )"),
+		Parses("ALTER TYPE name SET ( TYPMOD_OUT = type_modifier_output_function , SUBSCRIPT = subscript_function )"),
+		Parses("ALTER TYPE name SET ( ANALYZE = analyze_function , SUBSCRIPT = subscript_function )"),
+		Parses("ALTER TYPE name SET ( SUBSCRIPT = subscript_function , SUBSCRIPT = subscript_function )"),
+	}
+
+	RunTests(t, tests)
+	// RewriteTests(t, tests, "alter_type_test.go")
+}

testing/generation/command_docs/output/alter_user_mapping_test.go

@@ -0,0 +1,95 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterUserMapping(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("ALTER USER MAPPING FOR user_name SERVER server_name OPTIONS ( ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR USER SERVER server_name OPTIONS ( ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_ROLE SERVER server_name OPTIONS ( ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_USER SERVER server_name OPTIONS ( ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR SESSION_USER SERVER server_name OPTIONS ( ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR PUBLIC SERVER server_name OPTIONS ( ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR user_name SERVER server_name OPTIONS ( SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR USER SERVER server_name OPTIONS ( SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_ROLE SERVER server_name OPTIONS ( SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_USER SERVER server_name OPTIONS ( SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR SESSION_USER SERVER server_name OPTIONS ( SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR PUBLIC SERVER server_name OPTIONS ( SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR user_name SERVER server_name OPTIONS ( DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR USER SERVER server_name OPTIONS ( DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_ROLE SERVER server_name OPTIONS ( DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_USER SERVER server_name OPTIONS ( DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR SESSION_USER SERVER server_name OPTIONS ( DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR PUBLIC SERVER server_name OPTIONS ( DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR user_name SERVER server_name OPTIONS ( ADD option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR USER SERVER server_name OPTIONS ( ADD option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_ROLE SERVER server_name OPTIONS ( ADD option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_USER SERVER server_name OPTIONS ( ADD option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR SESSION_USER SERVER server_name OPTIONS ( ADD option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR PUBLIC SERVER server_name OPTIONS ( ADD option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR user_name SERVER server_name OPTIONS ( SET option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR USER SERVER server_name OPTIONS ( SET option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_ROLE SERVER server_name OPTIONS ( SET option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_USER SERVER server_name OPTIONS ( SET option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR SESSION_USER SERVER server_name OPTIONS ( SET option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR PUBLIC SERVER server_name OPTIONS ( SET option ' value ' , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR user_name SERVER server_name OPTIONS ( DROP option , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR USER SERVER server_name OPTIONS ( DROP option , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_ROLE SERVER server_name OPTIONS ( DROP option , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_USER SERVER server_name OPTIONS ( DROP option , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR SESSION_USER SERVER server_name OPTIONS ( DROP option , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR PUBLIC SERVER server_name OPTIONS ( DROP option , ADD option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR user_name SERVER server_name OPTIONS ( ADD option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR USER SERVER server_name OPTIONS ( ADD option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_ROLE SERVER server_name OPTIONS ( ADD option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_USER SERVER server_name OPTIONS ( ADD option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR SESSION_USER SERVER server_name OPTIONS ( ADD option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR PUBLIC SERVER server_name OPTIONS ( ADD option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR user_name SERVER server_name OPTIONS ( SET option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR USER SERVER server_name OPTIONS ( SET option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_ROLE SERVER server_name OPTIONS ( SET option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_USER SERVER server_name OPTIONS ( SET option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR SESSION_USER SERVER server_name OPTIONS ( SET option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR PUBLIC SERVER server_name OPTIONS ( SET option ' value ' , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR user_name SERVER server_name OPTIONS ( DROP option , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR USER SERVER server_name OPTIONS ( DROP option , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_ROLE SERVER server_name OPTIONS ( DROP option , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_USER SERVER server_name OPTIONS ( DROP option , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR SESSION_USER SERVER server_name OPTIONS ( DROP option , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR PUBLIC SERVER server_name OPTIONS ( DROP option , SET option ' value ' )"),
+		Unimplemented("ALTER USER MAPPING FOR user_name SERVER server_name OPTIONS ( ADD option ' value ' , DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR USER SERVER server_name OPTIONS ( ADD option ' value ' , DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_ROLE SERVER server_name OPTIONS ( ADD option ' value ' , DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_USER SERVER server_name OPTIONS ( ADD option ' value ' , DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR SESSION_USER SERVER server_name OPTIONS ( ADD option ' value ' , DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR PUBLIC SERVER server_name OPTIONS ( ADD option ' value ' , DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR user_name SERVER server_name OPTIONS ( SET option ' value ' , DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR USER SERVER server_name OPTIONS ( SET option ' value ' , DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_ROLE SERVER server_name OPTIONS ( SET option ' value ' , DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_USER SERVER server_name OPTIONS ( SET option ' value ' , DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR SESSION_USER SERVER server_name OPTIONS ( SET option ' value ' , DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR PUBLIC SERVER server_name OPTIONS ( SET option ' value ' , DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR user_name SERVER server_name OPTIONS ( DROP option , DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR USER SERVER server_name OPTIONS ( DROP option , DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_ROLE SERVER server_name OPTIONS ( DROP option , DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR CURRENT_USER SERVER server_name OPTIONS ( DROP option , DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR SESSION_USER SERVER server_name OPTIONS ( DROP option , DROP option )"),
+		Unimplemented("ALTER USER MAPPING FOR PUBLIC SERVER server_name OPTIONS ( DROP option , DROP option )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/alter_view_test.go

@@ -0,0 +1,157 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAlterView(t *testing.T) {
+	tests := []QueryParses{
+		Parses("ALTER VIEW name ALTER column_name SET DEFAULT expression"),
+		Parses("ALTER VIEW IF EXISTS name ALTER column_name SET DEFAULT expression"),
+		Parses("ALTER VIEW name ALTER COLUMN column_name SET DEFAULT expression"),
+		Parses("ALTER VIEW IF EXISTS name ALTER COLUMN column_name SET DEFAULT expression"),
+		Parses("ALTER VIEW name ALTER column_name DROP DEFAULT"),
+		Parses("ALTER VIEW IF EXISTS name ALTER column_name DROP DEFAULT"),
+		Parses("ALTER VIEW name ALTER COLUMN column_name DROP DEFAULT"),
+		Parses("ALTER VIEW IF EXISTS name ALTER COLUMN column_name DROP DEFAULT"),
+		Converts("ALTER VIEW name OWNER TO new_owner"),
+		Converts("ALTER VIEW IF EXISTS name OWNER TO new_owner"),
+		Converts("ALTER VIEW name OWNER TO CURRENT_ROLE"),
+		Converts("ALTER VIEW IF EXISTS name OWNER TO CURRENT_ROLE"),
+		Converts("ALTER VIEW name OWNER TO CURRENT_USER"),
+		Converts("ALTER VIEW IF EXISTS name OWNER TO CURRENT_USER"),
+		Converts("ALTER VIEW name OWNER TO SESSION_USER"),
+		Converts("ALTER VIEW IF EXISTS name OWNER TO SESSION_USER"),
+		Parses("ALTER VIEW name RENAME column_name TO new_column_name"),
+		Parses("ALTER VIEW IF EXISTS name RENAME column_name TO new_column_name"),
+		Parses("ALTER VIEW name RENAME COLUMN column_name TO new_column_name"),
+		Parses("ALTER VIEW IF EXISTS name RENAME COLUMN column_name TO new_column_name"),
+		Parses("ALTER VIEW name RENAME TO new_name"),
+		Parses("ALTER VIEW IF EXISTS name RENAME TO new_name"),
+		Parses("ALTER VIEW name SET SCHEMA new_schema"),
+		Parses("ALTER VIEW IF EXISTS name SET SCHEMA new_schema"),
+		Parses("ALTER VIEW name SET ( check_option )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( check_option )"),
+		Parses("ALTER VIEW name SET ( check_option = 'str' )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( check_option = 'str' )"),
+		Parses("ALTER VIEW name SET ( security_barrier )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_barrier )"),
+		Parses("ALTER VIEW name SET ( security_barrier = true )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_barrier = true )"),
+		Parses("ALTER VIEW name SET ( security_invoker )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_invoker )"),
+		Parses("ALTER VIEW name SET ( security_invoker = true )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_invoker = true )"),
+		Parses("ALTER VIEW name SET ( check_option , check_option )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( check_option , check_option )"),
+		Parses("ALTER VIEW name SET ( check_option = 'str' , check_option )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( check_option = 'str' , check_option )"),
+		Parses("ALTER VIEW name SET ( security_barrier , check_option )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_barrier , check_option )"),
+		Parses("ALTER VIEW name SET ( security_barrier = true , check_option )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_barrier = true , check_option )"),
+		Parses("ALTER VIEW name SET ( security_invoker , check_option )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_invoker , check_option )"),
+		Parses("ALTER VIEW name SET ( security_invoker = true , check_option )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_invoker = true , check_option )"),
+		Parses("ALTER VIEW name SET ( check_option , check_option = 'str' )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( check_option , check_option = 'str' )"),
+		Parses("ALTER VIEW name SET ( check_option = 'str' , check_option = 'str' )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( check_option = 'str' , check_option = 'str' )"),
+		Parses("ALTER VIEW name SET ( security_barrier , check_option = 'str' )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_barrier , check_option = 'str' )"),
+		Parses("ALTER VIEW name SET ( security_barrier = true , check_option = 'str' )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_barrier = true , check_option = 'str' )"),
+		Parses("ALTER VIEW name SET ( security_invoker , check_option = 'str' )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_invoker , check_option = 'str' )"),
+		Parses("ALTER VIEW name SET ( security_invoker = true , check_option = 'str' )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_invoker = true , check_option = 'str' )"),
+		Parses("ALTER VIEW name SET ( check_option , security_barrier )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( check_option , security_barrier )"),
+		Parses("ALTER VIEW name SET ( check_option = 'str' , security_barrier )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( check_option = 'str' , security_barrier )"),
+		Parses("ALTER VIEW name SET ( security_barrier , security_barrier )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_barrier , security_barrier )"),
+		Parses("ALTER VIEW name SET ( security_barrier = true , security_barrier )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_barrier = true , security_barrier )"),
+		Parses("ALTER VIEW name SET ( security_invoker , security_barrier )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_invoker , security_barrier )"),
+		Parses("ALTER VIEW name SET ( security_invoker = true , security_barrier )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_invoker = true , security_barrier )"),
+		Parses("ALTER VIEW name SET ( check_option , security_barrier = true )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( check_option , security_barrier = true )"),
+		Parses("ALTER VIEW name SET ( check_option = 'str' , security_barrier = true )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( check_option = 'str' , security_barrier = true )"),
+		Parses("ALTER VIEW name SET ( security_barrier , security_barrier = true )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_barrier , security_barrier = true )"),
+		Parses("ALTER VIEW name SET ( security_barrier = true , security_barrier = true )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_barrier = true , security_barrier = true )"),
+		Parses("ALTER VIEW name SET ( security_invoker , security_barrier = true )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_invoker , security_barrier = true )"),
+		Parses("ALTER VIEW name SET ( security_invoker = true , security_barrier = true )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_invoker = true , security_barrier = true )"),
+		Parses("ALTER VIEW name SET ( check_option , security_invoker )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( check_option , security_invoker )"),
+		Parses("ALTER VIEW name SET ( check_option = 'str' , security_invoker )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( check_option = 'str' , security_invoker )"),
+		Parses("ALTER VIEW name SET ( security_barrier , security_invoker )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_barrier , security_invoker )"),
+		Parses("ALTER VIEW name SET ( security_barrier = true , security_invoker )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_barrier = true , security_invoker )"),
+		Parses("ALTER VIEW name SET ( security_invoker , security_invoker )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_invoker , security_invoker )"),
+		Parses("ALTER VIEW name SET ( security_invoker = true , security_invoker )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_invoker = true , security_invoker )"),
+		Parses("ALTER VIEW name SET ( check_option , security_invoker = true )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( check_option , security_invoker = true )"),
+		Parses("ALTER VIEW name SET ( check_option = 'str' , security_invoker = true )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( check_option = 'str' , security_invoker = true )"),
+		Parses("ALTER VIEW name SET ( security_barrier , security_invoker = true )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_barrier , security_invoker = true )"),
+		Parses("ALTER VIEW name SET ( security_barrier = true , security_invoker = true )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_barrier = true , security_invoker = true )"),
+		Parses("ALTER VIEW name SET ( security_invoker , security_invoker = true )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_invoker , security_invoker = true )"),
+		Parses("ALTER VIEW name SET ( security_invoker = true , security_invoker = true )"),
+		Parses("ALTER VIEW IF EXISTS name SET ( security_invoker = true , security_invoker = true )"),
+		Parses("ALTER VIEW name RESET ( check_option )"),
+		Parses("ALTER VIEW IF EXISTS name RESET ( check_option )"),
+		Parses("ALTER VIEW name RESET ( security_barrier )"),
+		Parses("ALTER VIEW IF EXISTS name RESET ( security_barrier )"),
+		Parses("ALTER VIEW name RESET ( security_invoker )"),
+		Parses("ALTER VIEW IF EXISTS name RESET ( security_invoker )"),
+		Parses("ALTER VIEW name RESET ( check_option , check_option )"),
+		Parses("ALTER VIEW IF EXISTS name RESET ( check_option , check_option )"),
+		Parses("ALTER VIEW name RESET ( security_barrier , check_option )"),
+		Parses("ALTER VIEW IF EXISTS name RESET ( security_barrier , check_option )"),
+		Parses("ALTER VIEW name RESET ( security_invoker , check_option )"),
+		Parses("ALTER VIEW IF EXISTS name RESET ( security_invoker , check_option )"),
+		Parses("ALTER VIEW name RESET ( check_option , security_barrier )"),
+		Parses("ALTER VIEW IF EXISTS name RESET ( check_option , security_barrier )"),
+		Parses("ALTER VIEW name RESET ( security_barrier , security_barrier )"),
+		Parses("ALTER VIEW IF EXISTS name RESET ( security_barrier , security_barrier )"),
+		Parses("ALTER VIEW name RESET ( security_invoker , security_barrier )"),
+		Parses("ALTER VIEW IF EXISTS name RESET ( security_invoker , security_barrier )"),
+		Parses("ALTER VIEW name RESET ( check_option , security_invoker )"),
+		Parses("ALTER VIEW IF EXISTS name RESET ( check_option , security_invoker )"),
+		Parses("ALTER VIEW name RESET ( security_barrier , security_invoker )"),
+		Parses("ALTER VIEW IF EXISTS name RESET ( security_barrier , security_invoker )"),
+		Parses("ALTER VIEW name RESET ( security_invoker , security_invoker )"),
+		Parses("ALTER VIEW IF EXISTS name RESET ( security_invoker , security_invoker )"),
+	}
+
+	RunTests(t, tests)
+	// RewriteTests(t, tests, "alter_view_test.go")
+}

testing/generation/command_docs/output/analyze_test.go

@@ -0,0 +1,322 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestAnalyze(t *testing.T) {
+	tests := []QueryParses{
+		Converts("ANALYZE"),
+		Unimplemented("ANALYZE ( VERBOSE )"),
+		Unimplemented("ANALYZE ( VERBOSE true )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE true )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE true )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE true )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE true )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED true )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED true )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED true )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED true )"),
+		Converts("ANALYZE table_name"),
+		Unimplemented("ANALYZE ( VERBOSE ) table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true ) table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED ) table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true ) table_name"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE ) table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE ) table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE ) table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE ) table_name"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE true ) table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE true ) table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE true ) table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE true ) table_name"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED ) table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED ) table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED ) table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED ) table_name"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED true ) table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED true ) table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED true ) table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED true ) table_name"),
+		Unimplemented("ANALYZE table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE true ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE true ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE true ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE true ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED true ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED true ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED true ) table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED true ) table_name ( column_name )"),
+		Unimplemented("ANALYZE table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE true ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE true ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE true ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE true ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED true ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED true ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED true ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED true ) table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE table_name , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE ) table_name , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true ) table_name , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED ) table_name , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true ) table_name , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE ) table_name , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE ) table_name , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE ) table_name , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE ) table_name , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE true ) table_name , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE true ) table_name , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE true ) table_name , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE true ) table_name , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED ) table_name , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED ) table_name , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED ) table_name , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED ) table_name , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED true ) table_name , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED true ) table_name , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED true ) table_name , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED true ) table_name , table_name"),
+		Unimplemented("ANALYZE table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE true ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE true ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE true ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE true ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED true ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED true ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED true ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED true ) table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE true ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE true ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE true ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE true ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED true ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED true ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED true ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED true ) table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE true ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE true ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE true ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE true ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED true ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED true ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED true ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED true ) table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE true ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE true ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE true ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE true ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED true ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED true ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED true ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED true ) table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE true ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE true ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE true ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE true ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED true ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED true ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED true ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED true ) table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE true ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE true ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE true ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE true ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED true ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED true ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED true ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED true ) table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE true ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE true ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE true ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE true ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED true ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED true ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED true ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED true ) table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , VERBOSE true ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , VERBOSE true ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , VERBOSE true ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , VERBOSE true ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE , SKIP_LOCKED true ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( VERBOSE true , SKIP_LOCKED true ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED , SKIP_LOCKED true ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE ( SKIP_LOCKED true , SKIP_LOCKED true ) table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Converts("ANALYZE"),
+		Unimplemented("ANALYZE VERBOSE"),
+		Converts("ANALYZE table_name"),
+		Unimplemented("ANALYZE VERBOSE table_name"),
+		Unimplemented("ANALYZE table_name ( column_name )"),
+		Unimplemented("ANALYZE VERBOSE table_name ( column_name )"),
+		Unimplemented("ANALYZE table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE VERBOSE table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE table_name , table_name"),
+		Unimplemented("ANALYZE VERBOSE table_name , table_name"),
+		Unimplemented("ANALYZE table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE VERBOSE table_name ( column_name ) , table_name"),
+		Unimplemented("ANALYZE table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE VERBOSE table_name ( column_name , column_name ) , table_name"),
+		Unimplemented("ANALYZE table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE VERBOSE table_name , table_name ( column_name )"),
+		Unimplemented("ANALYZE table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE VERBOSE table_name ( column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE VERBOSE table_name ( column_name , column_name ) , table_name ( column_name )"),
+		Unimplemented("ANALYZE table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE VERBOSE table_name , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE VERBOSE table_name ( column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+		Unimplemented("ANALYZE VERBOSE table_name ( column_name , column_name ) , table_name ( column_name , column_name )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/begin_test.go

@@ -0,0 +1,242 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestBegin(t *testing.T) {
+	tests := []QueryParses{
+		Converts("BEGIN"),
+		Converts("BEGIN WORK"),
+		Converts("BEGIN TRANSACTION"),
+		Parses("BEGIN ISOLATION LEVEL SERIALIZABLE"),
+		Parses("BEGIN WORK ISOLATION LEVEL SERIALIZABLE"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE"),
+		Parses("BEGIN ISOLATION LEVEL REPEATABLE READ"),
+		Parses("BEGIN WORK ISOLATION LEVEL REPEATABLE READ"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ"),
+		Parses("BEGIN ISOLATION LEVEL READ COMMITTED"),
+		Parses("BEGIN WORK ISOLATION LEVEL READ COMMITTED"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED"),
+		Parses("BEGIN ISOLATION LEVEL READ UNCOMMITTED"),
+		Parses("BEGIN WORK ISOLATION LEVEL READ UNCOMMITTED"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL READ UNCOMMITTED"),
+		Converts("BEGIN READ WRITE"),
+		Converts("BEGIN WORK READ WRITE"),
+		Converts("BEGIN TRANSACTION READ WRITE"),
+		Converts("BEGIN READ ONLY"),
+		Converts("BEGIN WORK READ ONLY"),
+		Converts("BEGIN TRANSACTION READ ONLY"),
+		Parses("BEGIN DEFERRABLE"),
+		Parses("BEGIN WORK DEFERRABLE"),
+		Parses("BEGIN TRANSACTION DEFERRABLE"),
+		Parses("BEGIN NOT DEFERRABLE"),
+		Parses("BEGIN WORK NOT DEFERRABLE"),
+		Parses("BEGIN TRANSACTION NOT DEFERRABLE"),
+		Unimplemented("BEGIN ISOLATION LEVEL SERIALIZABLE , ISOLATION LEVEL SERIALIZABLE"),
+		Unimplemented("BEGIN WORK ISOLATION LEVEL SERIALIZABLE , ISOLATION LEVEL SERIALIZABLE"),
+		Unimplemented("BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE , ISOLATION LEVEL SERIALIZABLE"),
+		Unimplemented("BEGIN ISOLATION LEVEL REPEATABLE READ , ISOLATION LEVEL SERIALIZABLE"),
+		Unimplemented("BEGIN WORK ISOLATION LEVEL REPEATABLE READ , ISOLATION LEVEL SERIALIZABLE"),
+		Unimplemented("BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ , ISOLATION LEVEL SERIALIZABLE"),
+		Unimplemented("BEGIN ISOLATION LEVEL READ COMMITTED , ISOLATION LEVEL SERIALIZABLE"),
+		Unimplemented("BEGIN WORK ISOLATION LEVEL READ COMMITTED , ISOLATION LEVEL SERIALIZABLE"),
+		Unimplemented("BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED , ISOLATION LEVEL SERIALIZABLE"),
+		Unimplemented("BEGIN ISOLATION LEVEL READ UNCOMMITTED , ISOLATION LEVEL SERIALIZABLE"),
+		Unimplemented("BEGIN WORK ISOLATION LEVEL READ UNCOMMITTED , ISOLATION LEVEL SERIALIZABLE"),
+		Unimplemented("BEGIN TRANSACTION ISOLATION LEVEL READ UNCOMMITTED , ISOLATION LEVEL SERIALIZABLE"),
+		Parses("BEGIN READ WRITE , ISOLATION LEVEL SERIALIZABLE"),
+		Parses("BEGIN WORK READ WRITE , ISOLATION LEVEL SERIALIZABLE"),
+		Parses("BEGIN TRANSACTION READ WRITE , ISOLATION LEVEL SERIALIZABLE"),
+		Parses("BEGIN READ ONLY , ISOLATION LEVEL SERIALIZABLE"),
+		Parses("BEGIN WORK READ ONLY , ISOLATION LEVEL SERIALIZABLE"),
+		Parses("BEGIN TRANSACTION READ ONLY , ISOLATION LEVEL SERIALIZABLE"),
+		Parses("BEGIN DEFERRABLE , ISOLATION LEVEL SERIALIZABLE"),
+		Parses("BEGIN WORK DEFERRABLE , ISOLATION LEVEL SERIALIZABLE"),
+		Parses("BEGIN TRANSACTION DEFERRABLE , ISOLATION LEVEL SERIALIZABLE"),
+		Parses("BEGIN NOT DEFERRABLE , ISOLATION LEVEL SERIALIZABLE"),
+		Parses("BEGIN WORK NOT DEFERRABLE , ISOLATION LEVEL SERIALIZABLE"),
+		Parses("BEGIN TRANSACTION NOT DEFERRABLE , ISOLATION LEVEL SERIALIZABLE"),
+		Unimplemented("BEGIN ISOLATION LEVEL SERIALIZABLE , ISOLATION LEVEL REPEATABLE READ"),
+		Unimplemented("BEGIN WORK ISOLATION LEVEL SERIALIZABLE , ISOLATION LEVEL REPEATABLE READ"),
+		Unimplemented("BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE , ISOLATION LEVEL REPEATABLE READ"),
+		Unimplemented("BEGIN ISOLATION LEVEL REPEATABLE READ , ISOLATION LEVEL REPEATABLE READ"),
+		Unimplemented("BEGIN WORK ISOLATION LEVEL REPEATABLE READ , ISOLATION LEVEL REPEATABLE READ"),
+		Unimplemented("BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ , ISOLATION LEVEL REPEATABLE READ"),
+		Unimplemented("BEGIN ISOLATION LEVEL READ COMMITTED , ISOLATION LEVEL REPEATABLE READ"),
+		Unimplemented("BEGIN WORK ISOLATION LEVEL READ COMMITTED , ISOLATION LEVEL REPEATABLE READ"),
+		Unimplemented("BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED , ISOLATION LEVEL REPEATABLE READ"),
+		Unimplemented("BEGIN ISOLATION LEVEL READ UNCOMMITTED , ISOLATION LEVEL REPEATABLE READ"),
+		Unimplemented("BEGIN WORK ISOLATION LEVEL READ UNCOMMITTED , ISOLATION LEVEL REPEATABLE READ"),
+		Unimplemented("BEGIN TRANSACTION ISOLATION LEVEL READ UNCOMMITTED , ISOLATION LEVEL REPEATABLE READ"),
+		Parses("BEGIN READ WRITE , ISOLATION LEVEL REPEATABLE READ"),
+		Parses("BEGIN WORK READ WRITE , ISOLATION LEVEL REPEATABLE READ"),
+		Parses("BEGIN TRANSACTION READ WRITE , ISOLATION LEVEL REPEATABLE READ"),
+		Parses("BEGIN READ ONLY , ISOLATION LEVEL REPEATABLE READ"),
+		Parses("BEGIN WORK READ ONLY , ISOLATION LEVEL REPEATABLE READ"),
+		Parses("BEGIN TRANSACTION READ ONLY , ISOLATION LEVEL REPEATABLE READ"),
+		Parses("BEGIN DEFERRABLE , ISOLATION LEVEL REPEATABLE READ"),
+		Parses("BEGIN WORK DEFERRABLE , ISOLATION LEVEL REPEATABLE READ"),
+		Parses("BEGIN TRANSACTION DEFERRABLE , ISOLATION LEVEL REPEATABLE READ"),
+		Parses("BEGIN NOT DEFERRABLE , ISOLATION LEVEL REPEATABLE READ"),
+		Parses("BEGIN WORK NOT DEFERRABLE , ISOLATION LEVEL REPEATABLE READ"),
+		Parses("BEGIN TRANSACTION NOT DEFERRABLE , ISOLATION LEVEL REPEATABLE READ"),
+		Unimplemented("BEGIN ISOLATION LEVEL SERIALIZABLE , ISOLATION LEVEL READ COMMITTED"),
+		Unimplemented("BEGIN WORK ISOLATION LEVEL SERIALIZABLE , ISOLATION LEVEL READ COMMITTED"),
+		Unimplemented("BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE , ISOLATION LEVEL READ COMMITTED"),
+		Unimplemented("BEGIN ISOLATION LEVEL REPEATABLE READ , ISOLATION LEVEL READ COMMITTED"),
+		Unimplemented("BEGIN WORK ISOLATION LEVEL REPEATABLE READ , ISOLATION LEVEL READ COMMITTED"),
+		Unimplemented("BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ , ISOLATION LEVEL READ COMMITTED"),
+		Unimplemented("BEGIN ISOLATION LEVEL READ COMMITTED , ISOLATION LEVEL READ COMMITTED"),
+		Unimplemented("BEGIN WORK ISOLATION LEVEL READ COMMITTED , ISOLATION LEVEL READ COMMITTED"),
+		Unimplemented("BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED , ISOLATION LEVEL READ COMMITTED"),
+		Unimplemented("BEGIN ISOLATION LEVEL READ UNCOMMITTED , ISOLATION LEVEL READ COMMITTED"),
+		Unimplemented("BEGIN WORK ISOLATION LEVEL READ UNCOMMITTED , ISOLATION LEVEL READ COMMITTED"),
+		Unimplemented("BEGIN TRANSACTION ISOLATION LEVEL READ UNCOMMITTED , ISOLATION LEVEL READ COMMITTED"),
+		Parses("BEGIN READ WRITE , ISOLATION LEVEL READ COMMITTED"),
+		Parses("BEGIN WORK READ WRITE , ISOLATION LEVEL READ COMMITTED"),
+		Parses("BEGIN TRANSACTION READ WRITE , ISOLATION LEVEL READ COMMITTED"),
+		Parses("BEGIN READ ONLY , ISOLATION LEVEL READ COMMITTED"),
+		Parses("BEGIN WORK READ ONLY , ISOLATION LEVEL READ COMMITTED"),
+		Parses("BEGIN TRANSACTION READ ONLY , ISOLATION LEVEL READ COMMITTED"),
+		Parses("BEGIN DEFERRABLE , ISOLATION LEVEL READ COMMITTED"),
+		Parses("BEGIN WORK DEFERRABLE , ISOLATION LEVEL READ COMMITTED"),
+		Parses("BEGIN TRANSACTION DEFERRABLE , ISOLATION LEVEL READ COMMITTED"),
+		Parses("BEGIN NOT DEFERRABLE , ISOLATION LEVEL READ COMMITTED"),
+		Parses("BEGIN WORK NOT DEFERRABLE , ISOLATION LEVEL READ COMMITTED"),
+		Parses("BEGIN TRANSACTION NOT DEFERRABLE , ISOLATION LEVEL READ COMMITTED"),
+		Unimplemented("BEGIN ISOLATION LEVEL SERIALIZABLE , ISOLATION LEVEL READ UNCOMMITTED"),
+		Unimplemented("BEGIN WORK ISOLATION LEVEL SERIALIZABLE , ISOLATION LEVEL READ UNCOMMITTED"),
+		Unimplemented("BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE , ISOLATION LEVEL READ UNCOMMITTED"),
+		Unimplemented("BEGIN ISOLATION LEVEL REPEATABLE READ , ISOLATION LEVEL READ UNCOMMITTED"),
+		Unimplemented("BEGIN WORK ISOLATION LEVEL REPEATABLE READ , ISOLATION LEVEL READ UNCOMMITTED"),
+		Unimplemented("BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ , ISOLATION LEVEL READ UNCOMMITTED"),
+		Unimplemented("BEGIN ISOLATION LEVEL READ COMMITTED , ISOLATION LEVEL READ UNCOMMITTED"),
+		Unimplemented("BEGIN WORK ISOLATION LEVEL READ COMMITTED , ISOLATION LEVEL READ UNCOMMITTED"),
+		Unimplemented("BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED , ISOLATION LEVEL READ UNCOMMITTED"),
+		Unimplemented("BEGIN ISOLATION LEVEL READ UNCOMMITTED , ISOLATION LEVEL READ UNCOMMITTED"),
+		Unimplemented("BEGIN WORK ISOLATION LEVEL READ UNCOMMITTED , ISOLATION LEVEL READ UNCOMMITTED"),
+		Unimplemented("BEGIN TRANSACTION ISOLATION LEVEL READ UNCOMMITTED , ISOLATION LEVEL READ UNCOMMITTED"),
+		Parses("BEGIN READ WRITE , ISOLATION LEVEL READ UNCOMMITTED"),
+		Parses("BEGIN WORK READ WRITE , ISOLATION LEVEL READ UNCOMMITTED"),
+		Parses("BEGIN TRANSACTION READ WRITE , ISOLATION LEVEL READ UNCOMMITTED"),
+		Parses("BEGIN READ ONLY , ISOLATION LEVEL READ UNCOMMITTED"),
+		Parses("BEGIN WORK READ ONLY , ISOLATION LEVEL READ UNCOMMITTED"),
+		Parses("BEGIN TRANSACTION READ ONLY , ISOLATION LEVEL READ UNCOMMITTED"),
+		Parses("BEGIN DEFERRABLE , ISOLATION LEVEL READ UNCOMMITTED"),
+		Parses("BEGIN WORK DEFERRABLE , ISOLATION LEVEL READ UNCOMMITTED"),
+		Parses("BEGIN TRANSACTION DEFERRABLE , ISOLATION LEVEL READ UNCOMMITTED"),
+		Parses("BEGIN NOT DEFERRABLE , ISOLATION LEVEL READ UNCOMMITTED"),
+		Parses("BEGIN WORK NOT DEFERRABLE , ISOLATION LEVEL READ UNCOMMITTED"),
+		Parses("BEGIN TRANSACTION NOT DEFERRABLE , ISOLATION LEVEL READ UNCOMMITTED"),
+		Parses("BEGIN ISOLATION LEVEL SERIALIZABLE , READ WRITE"),
+		Parses("BEGIN WORK ISOLATION LEVEL SERIALIZABLE , READ WRITE"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE , READ WRITE"),
+		Parses("BEGIN ISOLATION LEVEL REPEATABLE READ , READ WRITE"),
+		Parses("BEGIN WORK ISOLATION LEVEL REPEATABLE READ , READ WRITE"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ , READ WRITE"),
+		Parses("BEGIN ISOLATION LEVEL READ COMMITTED , READ WRITE"),
+		Parses("BEGIN WORK ISOLATION LEVEL READ COMMITTED , READ WRITE"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED , READ WRITE"),
+		Parses("BEGIN ISOLATION LEVEL READ UNCOMMITTED , READ WRITE"),
+		Parses("BEGIN WORK ISOLATION LEVEL READ UNCOMMITTED , READ WRITE"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL READ UNCOMMITTED , READ WRITE"),
+		Unimplemented("BEGIN READ WRITE , READ WRITE"),
+		Unimplemented("BEGIN WORK READ WRITE , READ WRITE"),
+		Unimplemented("BEGIN TRANSACTION READ WRITE , READ WRITE"),
+		Unimplemented("BEGIN READ ONLY , READ WRITE"),
+		Unimplemented("BEGIN WORK READ ONLY , READ WRITE"),
+		Unimplemented("BEGIN TRANSACTION READ ONLY , READ WRITE"),
+		Parses("BEGIN DEFERRABLE , READ WRITE"),
+		Parses("BEGIN WORK DEFERRABLE , READ WRITE"),
+		Parses("BEGIN TRANSACTION DEFERRABLE , READ WRITE"),
+		Parses("BEGIN NOT DEFERRABLE , READ WRITE"),
+		Parses("BEGIN WORK NOT DEFERRABLE , READ WRITE"),
+		Parses("BEGIN TRANSACTION NOT DEFERRABLE , READ WRITE"),
+		Parses("BEGIN ISOLATION LEVEL SERIALIZABLE , READ ONLY"),
+		Parses("BEGIN WORK ISOLATION LEVEL SERIALIZABLE , READ ONLY"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE , READ ONLY"),
+		Parses("BEGIN ISOLATION LEVEL REPEATABLE READ , READ ONLY"),
+		Parses("BEGIN WORK ISOLATION LEVEL REPEATABLE READ , READ ONLY"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ , READ ONLY"),
+		Parses("BEGIN ISOLATION LEVEL READ COMMITTED , READ ONLY"),
+		Parses("BEGIN WORK ISOLATION LEVEL READ COMMITTED , READ ONLY"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED , READ ONLY"),
+		Parses("BEGIN ISOLATION LEVEL READ UNCOMMITTED , READ ONLY"),
+		Parses("BEGIN WORK ISOLATION LEVEL READ UNCOMMITTED , READ ONLY"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL READ UNCOMMITTED , READ ONLY"),
+		Unimplemented("BEGIN READ WRITE , READ ONLY"),
+		Unimplemented("BEGIN WORK READ WRITE , READ ONLY"),
+		Unimplemented("BEGIN TRANSACTION READ WRITE , READ ONLY"),
+		Unimplemented("BEGIN READ ONLY , READ ONLY"),
+		Unimplemented("BEGIN WORK READ ONLY , READ ONLY"),
+		Unimplemented("BEGIN TRANSACTION READ ONLY , READ ONLY"),
+		Parses("BEGIN DEFERRABLE , READ ONLY"),
+		Parses("BEGIN WORK DEFERRABLE , READ ONLY"),
+		Parses("BEGIN TRANSACTION DEFERRABLE , READ ONLY"),
+		Parses("BEGIN NOT DEFERRABLE , READ ONLY"),
+		Parses("BEGIN WORK NOT DEFERRABLE , READ ONLY"),
+		Parses("BEGIN TRANSACTION NOT DEFERRABLE , READ ONLY"),
+		Parses("BEGIN ISOLATION LEVEL SERIALIZABLE , DEFERRABLE"),
+		Parses("BEGIN WORK ISOLATION LEVEL SERIALIZABLE , DEFERRABLE"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE , DEFERRABLE"),
+		Parses("BEGIN ISOLATION LEVEL REPEATABLE READ , DEFERRABLE"),
+		Parses("BEGIN WORK ISOLATION LEVEL REPEATABLE READ , DEFERRABLE"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ , DEFERRABLE"),
+		Parses("BEGIN ISOLATION LEVEL READ COMMITTED , DEFERRABLE"),
+		Parses("BEGIN WORK ISOLATION LEVEL READ COMMITTED , DEFERRABLE"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED , DEFERRABLE"),
+		Parses("BEGIN ISOLATION LEVEL READ UNCOMMITTED , DEFERRABLE"),
+		Parses("BEGIN WORK ISOLATION LEVEL READ UNCOMMITTED , DEFERRABLE"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL READ UNCOMMITTED , DEFERRABLE"),
+		Parses("BEGIN READ WRITE , DEFERRABLE"),
+		Parses("BEGIN WORK READ WRITE , DEFERRABLE"),
+		Parses("BEGIN TRANSACTION READ WRITE , DEFERRABLE"),
+		Parses("BEGIN READ ONLY , DEFERRABLE"),
+		Parses("BEGIN WORK READ ONLY , DEFERRABLE"),
+		Parses("BEGIN TRANSACTION READ ONLY , DEFERRABLE"),
+		Unimplemented("BEGIN DEFERRABLE , DEFERRABLE"),
+		Unimplemented("BEGIN WORK DEFERRABLE , DEFERRABLE"),
+		Unimplemented("BEGIN TRANSACTION DEFERRABLE , DEFERRABLE"),
+		Unimplemented("BEGIN NOT DEFERRABLE , DEFERRABLE"),
+		Unimplemented("BEGIN WORK NOT DEFERRABLE , DEFERRABLE"),
+		Unimplemented("BEGIN TRANSACTION NOT DEFERRABLE , DEFERRABLE"),
+		Parses("BEGIN ISOLATION LEVEL SERIALIZABLE , NOT DEFERRABLE"),
+		Parses("BEGIN WORK ISOLATION LEVEL SERIALIZABLE , NOT DEFERRABLE"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE , NOT DEFERRABLE"),
+		Parses("BEGIN ISOLATION LEVEL REPEATABLE READ , NOT DEFERRABLE"),
+		Parses("BEGIN WORK ISOLATION LEVEL REPEATABLE READ , NOT DEFERRABLE"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ , NOT DEFERRABLE"),
+		Parses("BEGIN ISOLATION LEVEL READ COMMITTED , NOT DEFERRABLE"),
+		Parses("BEGIN WORK ISOLATION LEVEL READ COMMITTED , NOT DEFERRABLE"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED , NOT DEFERRABLE"),
+		Parses("BEGIN ISOLATION LEVEL READ UNCOMMITTED , NOT DEFERRABLE"),
+		Parses("BEGIN WORK ISOLATION LEVEL READ UNCOMMITTED , NOT DEFERRABLE"),
+		Parses("BEGIN TRANSACTION ISOLATION LEVEL READ UNCOMMITTED , NOT DEFERRABLE"),
+		Parses("BEGIN READ WRITE , NOT DEFERRABLE"),
+		Parses("BEGIN WORK READ WRITE , NOT DEFERRABLE"),
+		Parses("BEGIN TRANSACTION READ WRITE , NOT DEFERRABLE"),
+		Parses("BEGIN READ ONLY , NOT DEFERRABLE"),
+		Parses("BEGIN WORK READ ONLY , NOT DEFERRABLE"),
+		Parses("BEGIN TRANSACTION READ ONLY , NOT DEFERRABLE"),
+		Unimplemented("BEGIN DEFERRABLE , NOT DEFERRABLE"),
+		Unimplemented("BEGIN WORK DEFERRABLE , NOT DEFERRABLE"),
+		Unimplemented("BEGIN TRANSACTION DEFERRABLE , NOT DEFERRABLE"),
+		Unimplemented("BEGIN NOT DEFERRABLE , NOT DEFERRABLE"),
+		Unimplemented("BEGIN WORK NOT DEFERRABLE , NOT DEFERRABLE"),
+		Unimplemented("BEGIN TRANSACTION NOT DEFERRABLE , NOT DEFERRABLE"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/call_test.go

@@ -0,0 +1,26 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCall(t *testing.T) {
+	tests := []QueryParses{
+		Converts("CALL name ( )"),
+		Converts("CALL name ( argument )"),
+		Converts("CALL name ( argument , argument )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/checkpoint_test.go

@@ -0,0 +1,24 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCheckpoint(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CHECKPOINT"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/close_test.go

@@ -0,0 +1,25 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestClose(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CLOSE name"),
+		Unimplemented("CLOSE ALL"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/cluster_test.go

@@ -0,0 +1,41 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCluster(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CLUSTER table_name"),
+		Unimplemented("CLUSTER VERBOSE table_name"),
+		Unimplemented("CLUSTER table_name USING index_name"),
+		Unimplemented("CLUSTER VERBOSE table_name USING index_name"),
+		Unimplemented("CLUSTER ( VERBOSE ) table_name"),
+		Unimplemented("CLUSTER ( VERBOSE true ) table_name"),
+		Unimplemented("CLUSTER ( VERBOSE , VERBOSE ) table_name"),
+		Unimplemented("CLUSTER ( VERBOSE true , VERBOSE ) table_name"),
+		Unimplemented("CLUSTER ( VERBOSE , VERBOSE true ) table_name"),
+		Unimplemented("CLUSTER ( VERBOSE true , VERBOSE true ) table_name"),
+		Unimplemented("CLUSTER ( VERBOSE ) table_name USING index_name"),
+		Unimplemented("CLUSTER ( VERBOSE true ) table_name USING index_name"),
+		Unimplemented("CLUSTER ( VERBOSE , VERBOSE ) table_name USING index_name"),
+		Unimplemented("CLUSTER ( VERBOSE true , VERBOSE ) table_name USING index_name"),
+		Unimplemented("CLUSTER ( VERBOSE , VERBOSE true ) table_name USING index_name"),
+		Unimplemented("CLUSTER ( VERBOSE true , VERBOSE true ) table_name USING index_name"),
+		Unimplemented("CLUSTER"),
+		Unimplemented("CLUSTER VERBOSE"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/commit_prepared_test.go

@@ -0,0 +1,24 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCommitPrepared(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("COMMIT PREPARED 'id'"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/commit_test.go

@@ -0,0 +1,32 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCommit(t *testing.T) {
+	tests := []QueryParses{
+		Converts("COMMIT"),
+		Converts("COMMIT WORK"),
+		Converts("COMMIT TRANSACTION"),
+		Converts("COMMIT AND CHAIN"),
+		Converts("COMMIT WORK AND CHAIN"),
+		Converts("COMMIT TRANSACTION AND CHAIN"),
+		Converts("COMMIT AND NO CHAIN"),
+		Converts("COMMIT WORK AND NO CHAIN"),
+		Converts("COMMIT TRANSACTION AND NO CHAIN"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_access_method_test.go

@@ -0,0 +1,25 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateAccessMethod(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE ACCESS METHOD name TYPE TABLE HANDLER handler_function"),
+		Unimplemented("CREATE ACCESS METHOD name TYPE INDEX HANDLER handler_function"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_cast_test.go

@@ -0,0 +1,38 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateCast(t *testing.T) {
+	tests := []QueryParses{
+		Converts("CREATE CAST ( source_type AS target_type ) WITH FUNCTION function_name"),
+		Converts("CREATE CAST ( source_type AS target_type ) WITH FUNCTION function_name ( argument_type )"),
+		Converts("CREATE CAST ( source_type AS target_type ) WITH FUNCTION function_name ( argument_type , argument_type )"),
+		Converts("CREATE CAST ( source_type AS target_type ) WITH FUNCTION function_name AS ASSIGNMENT"),
+		Converts("CREATE CAST ( source_type AS target_type ) WITH FUNCTION function_name ( argument_type ) AS ASSIGNMENT"),
+		Converts("CREATE CAST ( source_type AS target_type ) WITH FUNCTION function_name ( argument_type , argument_type ) AS ASSIGNMENT"),
+		Converts("CREATE CAST ( source_type AS target_type ) WITH FUNCTION function_name AS IMPLICIT"),
+		Converts("CREATE CAST ( source_type AS target_type ) WITH FUNCTION function_name ( argument_type ) AS IMPLICIT"),
+		Converts("CREATE CAST ( source_type AS target_type ) WITH FUNCTION function_name ( argument_type , argument_type ) AS IMPLICIT"),
+		Converts("CREATE CAST ( source_type AS target_type ) WITHOUT FUNCTION"),
+		Converts("CREATE CAST ( source_type AS target_type ) WITHOUT FUNCTION AS ASSIGNMENT"),
+		Converts("CREATE CAST ( source_type AS target_type ) WITHOUT FUNCTION AS IMPLICIT"),
+		Converts("CREATE CAST ( source_type AS target_type ) WITH INOUT"),
+		Converts("CREATE CAST ( source_type AS target_type ) WITH INOUT AS ASSIGNMENT"),
+		Converts("CREATE CAST ( source_type AS target_type ) WITH INOUT AS IMPLICIT"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_collation_test.go

@@ -0,0 +1,103 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateCollation(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE COLLATION name ( LOCALE = locale )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LOCALE = locale )"),
+		Unimplemented("CREATE COLLATION name ( LC_COLLATE = lc_collate )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_COLLATE = lc_collate )"),
+		Unimplemented("CREATE COLLATION name ( LC_COLLATE = lc_collate , LC_CTYPE = lc_ctype )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_COLLATE = lc_collate , LC_CTYPE = lc_ctype )"),
+		Unimplemented("CREATE COLLATION name ( LC_CTYPE = lc_ctype )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_CTYPE = lc_ctype )"),
+		Unimplemented("CREATE COLLATION name ( LOCALE = locale , PROVIDER = provider )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LOCALE = locale , PROVIDER = provider )"),
+		Unimplemented("CREATE COLLATION name ( LC_COLLATE = lc_collate , PROVIDER = provider )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_COLLATE = lc_collate , PROVIDER = provider )"),
+		Unimplemented("CREATE COLLATION name ( LC_COLLATE = lc_collate , LC_CTYPE = lc_ctype , PROVIDER = provider )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_COLLATE = lc_collate , LC_CTYPE = lc_ctype , PROVIDER = provider )"),
+		Unimplemented("CREATE COLLATION name ( LC_CTYPE = lc_ctype , PROVIDER = provider )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_CTYPE = lc_ctype , PROVIDER = provider )"),
+		Unimplemented("CREATE COLLATION name ( LOCALE = locale , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LOCALE = locale , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION name ( LC_COLLATE = lc_collate , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_COLLATE = lc_collate , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION name ( LC_COLLATE = lc_collate , LC_CTYPE = lc_ctype , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_COLLATE = lc_collate , LC_CTYPE = lc_ctype , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION name ( LC_CTYPE = lc_ctype , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_CTYPE = lc_ctype , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION name ( LOCALE = locale , PROVIDER = provider , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LOCALE = locale , PROVIDER = provider , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION name ( LC_COLLATE = lc_collate , PROVIDER = provider , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_COLLATE = lc_collate , PROVIDER = provider , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION name ( LC_COLLATE = lc_collate , LC_CTYPE = lc_ctype , PROVIDER = provider , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_COLLATE = lc_collate , LC_CTYPE = lc_ctype , PROVIDER = provider , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION name ( LC_CTYPE = lc_ctype , PROVIDER = provider , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_CTYPE = lc_ctype , PROVIDER = provider , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION name ( LOCALE = locale , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LOCALE = locale , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( LC_COLLATE = lc_collate , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_COLLATE = lc_collate , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( LC_COLLATE = lc_collate , LC_CTYPE = lc_ctype , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_COLLATE = lc_collate , LC_CTYPE = lc_ctype , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( LC_CTYPE = lc_ctype , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_CTYPE = lc_ctype , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( LOCALE = locale , PROVIDER = provider , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LOCALE = locale , PROVIDER = provider , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( LC_COLLATE = lc_collate , PROVIDER = provider , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_COLLATE = lc_collate , PROVIDER = provider , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( LC_COLLATE = lc_collate , LC_CTYPE = lc_ctype , PROVIDER = provider , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_COLLATE = lc_collate , LC_CTYPE = lc_ctype , PROVIDER = provider , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( LC_CTYPE = lc_ctype , PROVIDER = provider , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_CTYPE = lc_ctype , PROVIDER = provider , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( LOCALE = locale , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LOCALE = locale , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( LC_COLLATE = lc_collate , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_COLLATE = lc_collate , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( LC_COLLATE = lc_collate , LC_CTYPE = lc_ctype , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_COLLATE = lc_collate , LC_CTYPE = lc_ctype , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( LC_CTYPE = lc_ctype , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_CTYPE = lc_ctype , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( LOCALE = locale , PROVIDER = provider , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LOCALE = locale , PROVIDER = provider , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( LC_COLLATE = lc_collate , PROVIDER = provider , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_COLLATE = lc_collate , PROVIDER = provider , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( LC_COLLATE = lc_collate , LC_CTYPE = lc_ctype , PROVIDER = provider , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_COLLATE = lc_collate , LC_CTYPE = lc_ctype , PROVIDER = provider , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( LC_CTYPE = lc_ctype , PROVIDER = provider , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( LC_CTYPE = lc_ctype , PROVIDER = provider , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( PROVIDER = provider )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( PROVIDER = provider )"),
+		Unimplemented("CREATE COLLATION name ( PROVIDER = provider , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( PROVIDER = provider , DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION name ( PROVIDER = provider , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( PROVIDER = provider , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( PROVIDER = provider , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( PROVIDER = provider , DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( DETERMINISTIC = true )"),
+		Unimplemented("CREATE COLLATION name ( DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( DETERMINISTIC = true , VERSION = version )"),
+		Unimplemented("CREATE COLLATION name ( VERSION = version )"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name ( VERSION = version )"),
+		Unimplemented("CREATE COLLATION name FROM existing_collation"),
+		Unimplemented("CREATE COLLATION IF NOT EXISTS name FROM existing_collation"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_conversion_test.go

@@ -0,0 +1,25 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateConversion(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE CONVERSION name FOR 'UTF8' TO 'UTF8' FROM function_name"),
+		Unimplemented("CREATE DEFAULT CONVERSION name FOR 'UTF8' TO 'UTF8' FROM function_name"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_domain_test.go

@@ -0,0 +1,367 @@
+// Copyright 2024 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateDomain(t *testing.T) {
+	tests := []QueryParses{
+		Converts("CREATE DOMAIN name data_type"),
+		Converts("CREATE DOMAIN name AS data_type"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US"),
+		Converts("CREATE DOMAIN name data_type DEFAULT expression"),
+		Converts("CREATE DOMAIN name AS data_type DEFAULT expression"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression"),
+		Converts("CREATE DOMAIN name data_type NOT NULL"),
+		Converts("CREATE DOMAIN name AS data_type NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US NOT NULL"),
+		Converts("CREATE DOMAIN name data_type DEFAULT expression NOT NULL"),
+		Converts("CREATE DOMAIN name AS data_type DEFAULT expression NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression NOT NULL"),
+		Converts("CREATE DOMAIN name data_type CONSTRAINT constraint_name NOT NULL"),
+		Converts("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name NOT NULL"),
+		Converts("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name NOT NULL"),
+		Converts("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NOT NULL"),
+		Converts("CREATE DOMAIN name data_type NULL"),
+		Converts("CREATE DOMAIN name AS data_type NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US NULL"),
+		Converts("CREATE DOMAIN name data_type DEFAULT expression NULL"),
+		Converts("CREATE DOMAIN name AS data_type DEFAULT expression NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression NULL"),
+		Converts("CREATE DOMAIN name data_type CONSTRAINT constraint_name NULL"),
+		Converts("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name NULL"),
+		Converts("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name NULL"),
+		Converts("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name CHECK ( expression )"),
+		Converts("CREATE DOMAIN name data_type NOT NULL NOT NULL"),
+		Converts("CREATE DOMAIN name AS data_type NOT NULL NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US NOT NULL NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US NOT NULL NOT NULL"),
+		Converts("CREATE DOMAIN name data_type DEFAULT expression NOT NULL NOT NULL"),
+		Converts("CREATE DOMAIN name AS data_type DEFAULT expression NOT NULL NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression NOT NULL NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression NOT NULL NOT NULL"),
+		Converts("CREATE DOMAIN name data_type CONSTRAINT constraint_name NOT NULL NOT NULL"),
+		Converts("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name NOT NULL NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name NOT NULL NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name NOT NULL NOT NULL"),
+		Converts("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name NOT NULL NOT NULL"),
+		Converts("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name NOT NULL NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NOT NULL NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NOT NULL NOT NULL"),
+		Parses("CREATE DOMAIN name data_type NULL NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type NULL NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US NULL NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US NULL NOT NULL"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression NULL NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression NULL NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression NULL NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression NULL NOT NULL"),
+		Parses("CREATE DOMAIN name data_type CONSTRAINT constraint_name NULL NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name NULL NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name NULL NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name NULL NOT NULL"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name NULL NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name NULL NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NULL NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NULL NOT NULL"),
+		Parses("CREATE DOMAIN name data_type CHECK ( expression ) NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type CHECK ( expression ) NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CHECK ( expression ) NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CHECK ( expression ) NOT NULL"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CHECK ( expression ) NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CHECK ( expression ) NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CHECK ( expression ) NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CHECK ( expression ) NOT NULL"),
+		Parses("CREATE DOMAIN name data_type CONSTRAINT constraint_name CHECK ( expression ) NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name CHECK ( expression ) NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name CHECK ( expression ) NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name CHECK ( expression ) NOT NULL"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) NOT NULL"),
+		Converts("CREATE DOMAIN name data_type NOT NULL CONSTRAINT constraint_name NOT NULL"),
+		Converts("CREATE DOMAIN name AS data_type NOT NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US NOT NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US NOT NULL CONSTRAINT constraint_name NOT NULL"),
+		Converts("CREATE DOMAIN name data_type DEFAULT expression NOT NULL CONSTRAINT constraint_name NOT NULL"),
+		Converts("CREATE DOMAIN name AS data_type DEFAULT expression NOT NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression NOT NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression NOT NULL CONSTRAINT constraint_name NOT NULL"),
+		Converts("CREATE DOMAIN name data_type CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name NOT NULL"),
+		Converts("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name NOT NULL"),
+		Converts("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name NOT NULL"),
+		Converts("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type CONSTRAINT constraint_name NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NULL CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type CHECK ( expression ) CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type CHECK ( expression ) CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CHECK ( expression ) CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CHECK ( expression ) CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CHECK ( expression ) CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CHECK ( expression ) CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CHECK ( expression ) CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CHECK ( expression ) CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name NOT NULL"),
+		Parses("CREATE DOMAIN name data_type NOT NULL NULL"),
+		Parses("CREATE DOMAIN name AS data_type NOT NULL NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US NOT NULL NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US NOT NULL NULL"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression NOT NULL NULL"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression NOT NULL NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression NOT NULL NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression NOT NULL NULL"),
+		Parses("CREATE DOMAIN name data_type CONSTRAINT constraint_name NOT NULL NULL"),
+		Parses("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name NOT NULL NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name NOT NULL NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name NOT NULL NULL"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name NOT NULL NULL"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name NOT NULL NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NOT NULL NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NOT NULL NULL"),
+		Converts("CREATE DOMAIN name data_type NULL NULL"),
+		Converts("CREATE DOMAIN name AS data_type NULL NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US NULL NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US NULL NULL"),
+		Converts("CREATE DOMAIN name data_type DEFAULT expression NULL NULL"),
+		Converts("CREATE DOMAIN name AS data_type DEFAULT expression NULL NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression NULL NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression NULL NULL"),
+		Converts("CREATE DOMAIN name data_type CONSTRAINT constraint_name NULL NULL"),
+		Converts("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name NULL NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name NULL NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name NULL NULL"),
+		Converts("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name NULL NULL"),
+		Converts("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name NULL NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NULL NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NULL NULL"),
+		Parses("CREATE DOMAIN name data_type CHECK ( expression ) NULL"),
+		Parses("CREATE DOMAIN name AS data_type CHECK ( expression ) NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CHECK ( expression ) NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CHECK ( expression ) NULL"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CHECK ( expression ) NULL"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CHECK ( expression ) NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CHECK ( expression ) NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CHECK ( expression ) NULL"),
+		Parses("CREATE DOMAIN name data_type CONSTRAINT constraint_name CHECK ( expression ) NULL"),
+		Parses("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name CHECK ( expression ) NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name CHECK ( expression ) NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name CHECK ( expression ) NULL"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) NULL"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) NULL"),
+		Parses("CREATE DOMAIN name data_type NOT NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type NOT NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US NOT NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US NOT NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression NOT NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression NOT NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression NOT NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression NOT NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name NULL"),
+		Converts("CREATE DOMAIN name data_type NULL CONSTRAINT constraint_name NULL"),
+		Converts("CREATE DOMAIN name AS data_type NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US NULL CONSTRAINT constraint_name NULL"),
+		Converts("CREATE DOMAIN name data_type DEFAULT expression NULL CONSTRAINT constraint_name NULL"),
+		Converts("CREATE DOMAIN name AS data_type DEFAULT expression NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression NULL CONSTRAINT constraint_name NULL"),
+		Converts("CREATE DOMAIN name data_type CONSTRAINT constraint_name NULL CONSTRAINT constraint_name NULL"),
+		Converts("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name NULL CONSTRAINT constraint_name NULL"),
+		Converts("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name NULL CONSTRAINT constraint_name NULL"),
+		Converts("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NULL CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type CHECK ( expression ) CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type CHECK ( expression ) CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CHECK ( expression ) CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CHECK ( expression ) CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CHECK ( expression ) CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CHECK ( expression ) CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CHECK ( expression ) CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CHECK ( expression ) CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name NULL"),
+		Parses("CREATE DOMAIN name data_type NOT NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type NOT NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US NOT NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US NOT NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression NOT NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression NOT NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression NOT NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression NOT NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type CONSTRAINT constraint_name NOT NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name NOT NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name NOT NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name NOT NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name NOT NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name NOT NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NOT NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NOT NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type CONSTRAINT constraint_name NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NULL CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type CHECK ( expression ) CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type CHECK ( expression ) CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CHECK ( expression ) CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CHECK ( expression ) CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CHECK ( expression ) CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CHECK ( expression ) CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CHECK ( expression ) CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CHECK ( expression ) CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type CONSTRAINT constraint_name CHECK ( expression ) CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name CHECK ( expression ) CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name CHECK ( expression ) CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name CHECK ( expression ) CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type NOT NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type NOT NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US NOT NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US NOT NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression NOT NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression NOT NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression NOT NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression NOT NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NOT NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type CONSTRAINT constraint_name NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name NULL CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type CHECK ( expression ) CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type CHECK ( expression ) CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CHECK ( expression ) CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CHECK ( expression ) CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CHECK ( expression ) CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CHECK ( expression ) CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CHECK ( expression ) CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CHECK ( expression ) CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name CHECK ( expression )"),
+		Parses("CREATE DOMAIN name AS data_type COLLATE en_US DEFAULT expression CONSTRAINT constraint_name CHECK ( expression ) CONSTRAINT constraint_name CHECK ( expression )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_event_trigger_test.go

@@ -0,0 +1,37 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateEventTrigger(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE EVENT TRIGGER name ON event EXECUTE FUNCTION function_name ( )"),
+		Unimplemented("CREATE EVENT TRIGGER name ON event WHEN filter_variable IN ( 'Active' ) EXECUTE FUNCTION function_name ( )"),
+		Unimplemented("CREATE EVENT TRIGGER name ON event WHEN filter_variable IN ( 'Active' , 'Active' ) EXECUTE FUNCTION function_name ( )"),
+		Unimplemented("CREATE EVENT TRIGGER name ON event WHEN filter_variable IN ( 'Active' ) AND filter_variable IN ( 'Active' ) EXECUTE FUNCTION function_name ( )"),
+		Unimplemented("CREATE EVENT TRIGGER name ON event WHEN filter_variable IN ( 'Active' , 'Active' ) AND filter_variable IN ( 'Active' ) EXECUTE FUNCTION function_name ( )"),
+		Unimplemented("CREATE EVENT TRIGGER name ON event WHEN filter_variable IN ( 'Active' ) AND filter_variable IN ( 'Active' , 'Active' ) EXECUTE FUNCTION function_name ( )"),
+		Unimplemented("CREATE EVENT TRIGGER name ON event WHEN filter_variable IN ( 'Active' , 'Active' ) AND filter_variable IN ( 'Active' , 'Active' ) EXECUTE FUNCTION function_name ( )"),
+		Unimplemented("CREATE EVENT TRIGGER name ON event EXECUTE PROCEDURE function_name ( )"),
+		Unimplemented("CREATE EVENT TRIGGER name ON event WHEN filter_variable IN ( 'Active' ) EXECUTE PROCEDURE function_name ( )"),
+		Unimplemented("CREATE EVENT TRIGGER name ON event WHEN filter_variable IN ( 'Active' , 'Active' ) EXECUTE PROCEDURE function_name ( )"),
+		Unimplemented("CREATE EVENT TRIGGER name ON event WHEN filter_variable IN ( 'Active' ) AND filter_variable IN ( 'Active' ) EXECUTE PROCEDURE function_name ( )"),
+		Unimplemented("CREATE EVENT TRIGGER name ON event WHEN filter_variable IN ( 'Active' , 'Active' ) AND filter_variable IN ( 'Active' ) EXECUTE PROCEDURE function_name ( )"),
+		Unimplemented("CREATE EVENT TRIGGER name ON event WHEN filter_variable IN ( 'Active' ) AND filter_variable IN ( 'Active' , 'Active' ) EXECUTE PROCEDURE function_name ( )"),
+		Unimplemented("CREATE EVENT TRIGGER name ON event WHEN filter_variable IN ( 'Active' , 'Active' ) AND filter_variable IN ( 'Active' , 'Active' ) EXECUTE PROCEDURE function_name ( )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_extension_test.go

@@ -0,0 +1,55 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateExtension(t *testing.T) {
+	tests := []QueryParses{
+		Converts("CREATE EXTENSION extension_name"),
+		Converts("CREATE EXTENSION IF NOT EXISTS extension_name"),
+		Converts("CREATE EXTENSION extension_name WITH"),
+		Converts("CREATE EXTENSION IF NOT EXISTS extension_name WITH"),
+		Parses("CREATE EXTENSION extension_name SCHEMA schema_name"),
+		Parses("CREATE EXTENSION IF NOT EXISTS extension_name SCHEMA schema_name"),
+		Parses("CREATE EXTENSION extension_name WITH SCHEMA schema_name"),
+		Parses("CREATE EXTENSION IF NOT EXISTS extension_name WITH SCHEMA schema_name"),
+		Parses("CREATE EXTENSION extension_name VERSION version"),
+		Parses("CREATE EXTENSION IF NOT EXISTS extension_name VERSION version"),
+		Parses("CREATE EXTENSION extension_name WITH VERSION version"),
+		Parses("CREATE EXTENSION IF NOT EXISTS extension_name WITH VERSION version"),
+		Parses("CREATE EXTENSION extension_name SCHEMA schema_name VERSION version"),
+		Parses("CREATE EXTENSION IF NOT EXISTS extension_name SCHEMA schema_name VERSION version"),
+		Parses("CREATE EXTENSION extension_name WITH SCHEMA schema_name VERSION version"),
+		Parses("CREATE EXTENSION IF NOT EXISTS extension_name WITH SCHEMA schema_name VERSION version"),
+		Parses("CREATE EXTENSION extension_name CASCADE"),
+		Parses("CREATE EXTENSION IF NOT EXISTS extension_name CASCADE"),
+		Parses("CREATE EXTENSION extension_name WITH CASCADE"),
+		Parses("CREATE EXTENSION IF NOT EXISTS extension_name WITH CASCADE"),
+		Parses("CREATE EXTENSION extension_name SCHEMA schema_name CASCADE"),
+		Parses("CREATE EXTENSION IF NOT EXISTS extension_name SCHEMA schema_name CASCADE"),
+		Parses("CREATE EXTENSION extension_name WITH SCHEMA schema_name CASCADE"),
+		Parses("CREATE EXTENSION IF NOT EXISTS extension_name WITH SCHEMA schema_name CASCADE"),
+		Parses("CREATE EXTENSION extension_name VERSION version CASCADE"),
+		Parses("CREATE EXTENSION IF NOT EXISTS extension_name VERSION version CASCADE"),
+		Parses("CREATE EXTENSION extension_name WITH VERSION version CASCADE"),
+		Parses("CREATE EXTENSION IF NOT EXISTS extension_name WITH VERSION version CASCADE"),
+		Parses("CREATE EXTENSION extension_name SCHEMA schema_name VERSION version CASCADE"),
+		Parses("CREATE EXTENSION IF NOT EXISTS extension_name SCHEMA schema_name VERSION version CASCADE"),
+		Parses("CREATE EXTENSION extension_name WITH SCHEMA schema_name VERSION version CASCADE"),
+		Parses("CREATE EXTENSION IF NOT EXISTS extension_name WITH SCHEMA schema_name VERSION version CASCADE"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_foreign_data_wrapper_test.go

@@ -0,0 +1,50 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateForeignDataWrapper(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name HANDLER handler_function"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name NO HANDLER"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name VALIDATOR validator_function"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name HANDLER handler_function VALIDATOR validator_function"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name NO HANDLER VALIDATOR validator_function"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name NO VALIDATOR"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name HANDLER handler_function NO VALIDATOR"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name NO HANDLER NO VALIDATOR"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name HANDLER handler_function OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name NO HANDLER OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name VALIDATOR validator_function OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name HANDLER handler_function VALIDATOR validator_function OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name NO HANDLER VALIDATOR validator_function OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name NO VALIDATOR OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name HANDLER handler_function NO VALIDATOR OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name NO HANDLER NO VALIDATOR OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name HANDLER handler_function OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name NO HANDLER OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name VALIDATOR validator_function OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name HANDLER handler_function VALIDATOR validator_function OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name NO HANDLER VALIDATOR validator_function OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name NO VALIDATOR OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name HANDLER handler_function NO VALIDATOR OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE FOREIGN DATA WRAPPER name NO HANDLER NO VALIDATOR OPTIONS ( option ' value ' , option ' value ' )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_language_test.go

@@ -0,0 +1,63 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateLanguage(t *testing.T) {
+	tests := []QueryParses{
+		Parses("CREATE LANGUAGE name HANDLER call_handler"),
+		Parses("CREATE OR REPLACE LANGUAGE name HANDLER call_handler"),
+		Parses("CREATE TRUSTED LANGUAGE name HANDLER call_handler"),
+		Parses("CREATE OR REPLACE TRUSTED LANGUAGE name HANDLER call_handler"),
+		Parses("CREATE PROCEDURAL LANGUAGE name HANDLER call_handler"),
+		Parses("CREATE OR REPLACE PROCEDURAL LANGUAGE name HANDLER call_handler"),
+		Parses("CREATE TRUSTED PROCEDURAL LANGUAGE name HANDLER call_handler"),
+		Parses("CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE name HANDLER call_handler"),
+		Parses("CREATE LANGUAGE name HANDLER call_handler INLINE inline_handler"),
+		Parses("CREATE OR REPLACE LANGUAGE name HANDLER call_handler INLINE inline_handler"),
+		Parses("CREATE TRUSTED LANGUAGE name HANDLER call_handler INLINE inline_handler"),
+		Parses("CREATE OR REPLACE TRUSTED LANGUAGE name HANDLER call_handler INLINE inline_handler"),
+		Parses("CREATE PROCEDURAL LANGUAGE name HANDLER call_handler INLINE inline_handler"),
+		Parses("CREATE OR REPLACE PROCEDURAL LANGUAGE name HANDLER call_handler INLINE inline_handler"),
+		Parses("CREATE TRUSTED PROCEDURAL LANGUAGE name HANDLER call_handler INLINE inline_handler"),
+		Parses("CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE name HANDLER call_handler INLINE inline_handler"),
+		Parses("CREATE LANGUAGE name HANDLER call_handler VALIDATOR valfunction"),
+		Parses("CREATE OR REPLACE LANGUAGE name HANDLER call_handler VALIDATOR valfunction"),
+		Parses("CREATE TRUSTED LANGUAGE name HANDLER call_handler VALIDATOR valfunction"),
+		Parses("CREATE OR REPLACE TRUSTED LANGUAGE name HANDLER call_handler VALIDATOR valfunction"),
+		Parses("CREATE PROCEDURAL LANGUAGE name HANDLER call_handler VALIDATOR valfunction"),
+		Parses("CREATE OR REPLACE PROCEDURAL LANGUAGE name HANDLER call_handler VALIDATOR valfunction"),
+		Parses("CREATE TRUSTED PROCEDURAL LANGUAGE name HANDLER call_handler VALIDATOR valfunction"),
+		Parses("CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE name HANDLER call_handler VALIDATOR valfunction"),
+		Parses("CREATE LANGUAGE name HANDLER call_handler INLINE inline_handler VALIDATOR valfunction"),
+		Parses("CREATE OR REPLACE LANGUAGE name HANDLER call_handler INLINE inline_handler VALIDATOR valfunction"),
+		Parses("CREATE TRUSTED LANGUAGE name HANDLER call_handler INLINE inline_handler VALIDATOR valfunction"),
+		Parses("CREATE OR REPLACE TRUSTED LANGUAGE name HANDLER call_handler INLINE inline_handler VALIDATOR valfunction"),
+		Parses("CREATE PROCEDURAL LANGUAGE name HANDLER call_handler INLINE inline_handler VALIDATOR valfunction"),
+		Parses("CREATE OR REPLACE PROCEDURAL LANGUAGE name HANDLER call_handler INLINE inline_handler VALIDATOR valfunction"),
+		Parses("CREATE TRUSTED PROCEDURAL LANGUAGE name HANDLER call_handler INLINE inline_handler VALIDATOR valfunction"),
+		Parses("CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE name HANDLER call_handler INLINE inline_handler VALIDATOR valfunction"),
+		Parses("CREATE LANGUAGE name"),
+		Parses("CREATE OR REPLACE LANGUAGE name"),
+		Parses("CREATE TRUSTED LANGUAGE name"),
+		Parses("CREATE OR REPLACE TRUSTED LANGUAGE name"),
+		Parses("CREATE PROCEDURAL LANGUAGE name"),
+		Parses("CREATE OR REPLACE PROCEDURAL LANGUAGE name"),
+		Parses("CREATE TRUSTED PROCEDURAL LANGUAGE name"),
+		Parses("CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE name"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_materialized_view_test.go

@@ -0,0 +1,527 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateMaterializedView(t *testing.T) {
+	tests := []QueryParses{
+		Parses("CREATE MATERIALIZED VIEW table_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1"),
+		Parses("CREATE MATERIALIZED VIEW table_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+		Parses("CREATE MATERIALIZED VIEW IF NOT EXISTS table_name ( column_name , column_name ) USING method WITH ( fillfactor = value , fillfactor = value ) TABLESPACE tablespace_name AS SELECT 1 WITH NO DATA"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_operator_class_test.go

@@ -0,0 +1,751 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateOperatorClass(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS STORAGE storage_type , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS STORAGE storage_type , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , OPERATOR 3 @@"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS STORAGE storage_type , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS STORAGE storage_type , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , OPERATOR 3 @@ ( op_type , op_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS STORAGE storage_type , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS STORAGE storage_type , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , OPERATOR 3 @@ FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS STORAGE storage_type , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS STORAGE storage_type , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS STORAGE storage_type , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS STORAGE storage_type , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , OPERATOR 3 @@ FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS STORAGE storage_type , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS STORAGE storage_type , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS STORAGE storage_type , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS STORAGE storage_type , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , FUNCTION 3 function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS STORAGE storage_type , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS STORAGE storage_type , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , FUNCTION 3 ( op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS STORAGE storage_type , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS STORAGE storage_type , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS STORAGE storage_type , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS STORAGE storage_type , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , FUNCTION 3 function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS STORAGE storage_type , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS STORAGE storage_type , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS STORAGE storage_type , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS STORAGE storage_type , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type )"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR SEARCH , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR SEARCH , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR SEARCH , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ FOR ORDER BY sort_family_name , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS OPERATOR 3 @@ ( op_type , op_type ) FOR ORDER BY sort_family_name , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 function_name ( argument_type , argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 function_name ( argument_type , argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type ) function_name ( argument_type , argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS FUNCTION 3 ( op_type , op_type ) function_name ( argument_type , argument_type ) , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method AS STORAGE storage_type , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method AS STORAGE storage_type , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , STORAGE storage_type"),
+		Unimplemented("CREATE OPERATOR CLASS name DEFAULT FOR TYPE data_type USING index_method FAMILY family_name AS STORAGE storage_type , STORAGE storage_type"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_operator_family_test.go

@@ -0,0 +1,24 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateOperatorFamily(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE OPERATOR FAMILY name USING index_method"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_operator_test.go

@@ -0,0 +1,535 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateOperator(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , NEGATOR = neg_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , NEGATOR = neg_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , NEGATOR = neg_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , NEGATOR = neg_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , NEGATOR = neg_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , NEGATOR = neg_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , NEGATOR = neg_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , NEGATOR = neg_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , NEGATOR = neg_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , NEGATOR = neg_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , NEGATOR = neg_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , NEGATOR = neg_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , NEGATOR = neg_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , NEGATOR = neg_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , NEGATOR = neg_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , NEGATOR = neg_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , NEGATOR = neg_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , NEGATOR = neg_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , NEGATOR = neg_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , NEGATOR = neg_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , NEGATOR = neg_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , NEGATOR = neg_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , NEGATOR = neg_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , NEGATOR = neg_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , NEGATOR = neg_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , NEGATOR = neg_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , NEGATOR = neg_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , NEGATOR = neg_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , NEGATOR = neg_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , NEGATOR = neg_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , NEGATOR = neg_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , NEGATOR = neg_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , NEGATOR = neg_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , NEGATOR = neg_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , NEGATOR = neg_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , NEGATOR = neg_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , NEGATOR = neg_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , NEGATOR = neg_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , NEGATOR = neg_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , NEGATOR = neg_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , NEGATOR = neg_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , NEGATOR = neg_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , NEGATOR = neg_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , NEGATOR = neg_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , NEGATOR = neg_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , NEGATOR = neg_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , NEGATOR = neg_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , NEGATOR = neg_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , NEGATOR = neg_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , NEGATOR = neg_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , NEGATOR = neg_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , NEGATOR = neg_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , NEGATOR = neg_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , NEGATOR = neg_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , NEGATOR = neg_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , NEGATOR = neg_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , NEGATOR = neg_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , NEGATOR = neg_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , NEGATOR = neg_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , NEGATOR = neg_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , NEGATOR = neg_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , NEGATOR = neg_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , NEGATOR = neg_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , NEGATOR = neg_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , NEGATOR = neg_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , NEGATOR = neg_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( FUNCTION = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+		Unimplemented("CREATE OPERATOR @@ ( PROCEDURE = function_name , LEFTARG = left_type , RIGHTARG = right_type , COMMUTATOR = com_op , NEGATOR = neg_op , RESTRICT = res_proc , JOIN = join_proc , HASHES , MERGES )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_rule_test.go

@@ -0,0 +1,215 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateRule(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name DO NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name DO NOTHING"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name DO NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name DO NOTHING"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name DO NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name DO NOTHING"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name DO NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name DO NOTHING"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name WHERE condition DO NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name WHERE condition DO NOTHING"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name WHERE condition DO NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name WHERE condition DO NOTHING"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name WHERE condition DO NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name WHERE condition DO NOTHING"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name WHERE condition DO NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name WHERE condition DO NOTHING"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name DO ALSO NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name DO ALSO NOTHING"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name DO ALSO NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name DO ALSO NOTHING"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name DO ALSO NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name DO ALSO NOTHING"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name DO ALSO NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name DO ALSO NOTHING"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name WHERE condition DO ALSO NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name WHERE condition DO ALSO NOTHING"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name WHERE condition DO ALSO NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name WHERE condition DO ALSO NOTHING"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name WHERE condition DO ALSO NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name WHERE condition DO ALSO NOTHING"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name WHERE condition DO ALSO NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name WHERE condition DO ALSO NOTHING"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name DO INSTEAD NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name DO INSTEAD NOTHING"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name DO INSTEAD NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name DO INSTEAD NOTHING"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name DO INSTEAD NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name DO INSTEAD NOTHING"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name DO INSTEAD NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name DO INSTEAD NOTHING"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name WHERE condition DO INSTEAD NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name WHERE condition DO INSTEAD NOTHING"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name WHERE condition DO INSTEAD NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name WHERE condition DO INSTEAD NOTHING"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name WHERE condition DO INSTEAD NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name WHERE condition DO INSTEAD NOTHING"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name WHERE condition DO INSTEAD NOTHING"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name WHERE condition DO INSTEAD NOTHING"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name DO SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name DO SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name DO SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name DO SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name DO SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name DO SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name DO SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name DO SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name WHERE condition DO SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name WHERE condition DO SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name WHERE condition DO SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name WHERE condition DO SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name WHERE condition DO SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name WHERE condition DO SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name WHERE condition DO SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name WHERE condition DO SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name DO ALSO SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name DO ALSO SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name DO ALSO SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name DO ALSO SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name DO ALSO SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name DO ALSO SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name DO ALSO SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name DO ALSO SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name WHERE condition DO ALSO SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name WHERE condition DO ALSO SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name WHERE condition DO ALSO SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name WHERE condition DO ALSO SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name WHERE condition DO ALSO SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name WHERE condition DO ALSO SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name WHERE condition DO ALSO SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name WHERE condition DO ALSO SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name DO INSTEAD SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name DO INSTEAD SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name DO INSTEAD SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name DO INSTEAD SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name DO INSTEAD SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name DO INSTEAD SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name DO INSTEAD SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name DO INSTEAD SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name WHERE condition DO INSTEAD SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name WHERE condition DO INSTEAD SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name WHERE condition DO INSTEAD SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name WHERE condition DO INSTEAD SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name WHERE condition DO INSTEAD SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name WHERE condition DO INSTEAD SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name WHERE condition DO INSTEAD SELECT 'abc'"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name WHERE condition DO INSTEAD SELECT 'abc'"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name DO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name DO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name DO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name DO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name DO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name DO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name DO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name DO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name WHERE condition DO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name WHERE condition DO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name WHERE condition DO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name WHERE condition DO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name WHERE condition DO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name WHERE condition DO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name WHERE condition DO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name WHERE condition DO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name DO ALSO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name DO ALSO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name DO ALSO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name DO ALSO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name DO ALSO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name DO ALSO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name DO ALSO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name DO ALSO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name WHERE condition DO ALSO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name WHERE condition DO ALSO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name WHERE condition DO ALSO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name WHERE condition DO ALSO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name WHERE condition DO ALSO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name WHERE condition DO ALSO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name WHERE condition DO ALSO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name WHERE condition DO ALSO ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name WHERE condition DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name WHERE condition DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name WHERE condition DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name WHERE condition DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name WHERE condition DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name WHERE condition DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name WHERE condition DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name WHERE condition DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name DO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name DO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name DO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name DO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name DO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name DO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name DO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name DO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name WHERE condition DO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name WHERE condition DO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name WHERE condition DO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name WHERE condition DO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name WHERE condition DO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name WHERE condition DO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name WHERE condition DO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name WHERE condition DO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name DO ALSO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name DO ALSO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name DO ALSO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name DO ALSO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name DO ALSO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name DO ALSO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name DO ALSO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name DO ALSO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name WHERE condition DO ALSO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name WHERE condition DO ALSO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name WHERE condition DO ALSO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name WHERE condition DO ALSO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name WHERE condition DO ALSO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name WHERE condition DO ALSO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name WHERE condition DO ALSO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name WHERE condition DO ALSO ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON SELECT TO table_name WHERE condition DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON SELECT TO table_name WHERE condition DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON INSERT TO table_name WHERE condition DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON INSERT TO table_name WHERE condition DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON UPDATE TO table_name WHERE condition DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON UPDATE TO table_name WHERE condition DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE RULE name AS ON DELETE TO table_name WHERE condition DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+		Unimplemented("CREATE OR REPLACE RULE name AS ON DELETE TO table_name WHERE condition DO INSTEAD ( SELECT 'abc' ; SELECT 'abc' ; SELECT 'abc' )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_schema_test.go

@@ -0,0 +1,59 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateSchema(t *testing.T) {
+	tests := []QueryParses{
+		Converts("CREATE SCHEMA schema_name"),
+		Converts("CREATE SCHEMA schema_name AUTHORIZATION user_name"),
+		Converts("CREATE SCHEMA schema_name AUTHORIZATION CURRENT_ROLE"),
+		Converts("CREATE SCHEMA schema_name AUTHORIZATION CURRENT_USER"),
+		Converts("CREATE SCHEMA schema_name AUTHORIZATION SESSION_USER"),
+		Converts("CREATE SCHEMA schema_name CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA schema_name AUTHORIZATION user_name CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA schema_name AUTHORIZATION CURRENT_ROLE CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA schema_name AUTHORIZATION CURRENT_USER CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA schema_name AUTHORIZATION SESSION_USER CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA schema_name CREATE TABLE tablename ( ) CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA schema_name AUTHORIZATION user_name CREATE TABLE tablename ( ) CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA schema_name AUTHORIZATION CURRENT_ROLE CREATE TABLE tablename ( ) CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA schema_name AUTHORIZATION CURRENT_USER CREATE TABLE tablename ( ) CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA schema_name AUTHORIZATION SESSION_USER CREATE TABLE tablename ( ) CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA AUTHORIZATION user_name"),
+		Converts("CREATE SCHEMA AUTHORIZATION CURRENT_ROLE"),
+		Converts("CREATE SCHEMA AUTHORIZATION CURRENT_USER"),
+		Converts("CREATE SCHEMA AUTHORIZATION SESSION_USER"),
+		Converts("CREATE SCHEMA AUTHORIZATION user_name CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA AUTHORIZATION CURRENT_ROLE CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA AUTHORIZATION CURRENT_USER CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA AUTHORIZATION SESSION_USER CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA AUTHORIZATION user_name CREATE TABLE tablename ( ) CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA AUTHORIZATION CURRENT_ROLE CREATE TABLE tablename ( ) CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA AUTHORIZATION CURRENT_USER CREATE TABLE tablename ( ) CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA AUTHORIZATION SESSION_USER CREATE TABLE tablename ( ) CREATE TABLE tablename ( )"),
+		Converts("CREATE SCHEMA IF NOT EXISTS schema_name"),
+		Converts("CREATE SCHEMA IF NOT EXISTS schema_name AUTHORIZATION user_name"),
+		Converts("CREATE SCHEMA IF NOT EXISTS schema_name AUTHORIZATION CURRENT_ROLE"),
+		Converts("CREATE SCHEMA IF NOT EXISTS schema_name AUTHORIZATION CURRENT_USER"),
+		Converts("CREATE SCHEMA IF NOT EXISTS schema_name AUTHORIZATION SESSION_USER"),
+		Converts("CREATE SCHEMA IF NOT EXISTS AUTHORIZATION user_name"),
+		Converts("CREATE SCHEMA IF NOT EXISTS AUTHORIZATION CURRENT_ROLE"),
+		Converts("CREATE SCHEMA IF NOT EXISTS AUTHORIZATION CURRENT_USER"),
+		Converts("CREATE SCHEMA IF NOT EXISTS AUTHORIZATION SESSION_USER"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_server_test.go

@@ -0,0 +1,47 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateServer(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE SERVER server_name FOREIGN DATA WRAPPER fdw_name"),
+		Unimplemented("CREATE SERVER IF NOT EXISTS server_name FOREIGN DATA WRAPPER fdw_name"),
+		Unimplemented("CREATE SERVER server_name TYPE ' server_type ' FOREIGN DATA WRAPPER fdw_name"),
+		Unimplemented("CREATE SERVER IF NOT EXISTS server_name TYPE ' server_type ' FOREIGN DATA WRAPPER fdw_name"),
+		Unimplemented("CREATE SERVER server_name VERSION ' server_version ' FOREIGN DATA WRAPPER fdw_name"),
+		Unimplemented("CREATE SERVER IF NOT EXISTS server_name VERSION ' server_version ' FOREIGN DATA WRAPPER fdw_name"),
+		Unimplemented("CREATE SERVER server_name TYPE ' server_type ' VERSION ' server_version ' FOREIGN DATA WRAPPER fdw_name"),
+		Unimplemented("CREATE SERVER IF NOT EXISTS server_name TYPE ' server_type ' VERSION ' server_version ' FOREIGN DATA WRAPPER fdw_name"),
+		Unimplemented("CREATE SERVER server_name FOREIGN DATA WRAPPER fdw_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE SERVER IF NOT EXISTS server_name FOREIGN DATA WRAPPER fdw_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE SERVER server_name TYPE ' server_type ' FOREIGN DATA WRAPPER fdw_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE SERVER IF NOT EXISTS server_name TYPE ' server_type ' FOREIGN DATA WRAPPER fdw_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE SERVER server_name VERSION ' server_version ' FOREIGN DATA WRAPPER fdw_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE SERVER IF NOT EXISTS server_name VERSION ' server_version ' FOREIGN DATA WRAPPER fdw_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE SERVER server_name TYPE ' server_type ' VERSION ' server_version ' FOREIGN DATA WRAPPER fdw_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE SERVER IF NOT EXISTS server_name TYPE ' server_type ' VERSION ' server_version ' FOREIGN DATA WRAPPER fdw_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE SERVER server_name FOREIGN DATA WRAPPER fdw_name OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE SERVER IF NOT EXISTS server_name FOREIGN DATA WRAPPER fdw_name OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE SERVER server_name TYPE ' server_type ' FOREIGN DATA WRAPPER fdw_name OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE SERVER IF NOT EXISTS server_name TYPE ' server_type ' FOREIGN DATA WRAPPER fdw_name OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE SERVER server_name VERSION ' server_version ' FOREIGN DATA WRAPPER fdw_name OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE SERVER IF NOT EXISTS server_name VERSION ' server_version ' FOREIGN DATA WRAPPER fdw_name OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE SERVER server_name TYPE ' server_type ' VERSION ' server_version ' FOREIGN DATA WRAPPER fdw_name OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE SERVER IF NOT EXISTS server_name TYPE ' server_type ' VERSION ' server_version ' FOREIGN DATA WRAPPER fdw_name OPTIONS ( option ' value ' , option ' value ' )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_statistics_test.go

@@ -0,0 +1,97 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateStatistics(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE STATISTICS statistics_name ON ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ON ( expression ) FROM table_name"),
+		Parses("CREATE STATISTICS statistics_name ON column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ON column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind ) ON column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind ) ON column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind , statistics_kind ) ON column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind , statistics_kind ) ON column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ON ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ON ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind ) ON ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind ) ON ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind , statistics_kind ) ON ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind , statistics_kind ) ON ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ON column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ON column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind ) ON column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind ) ON column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind , statistics_kind ) ON column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind , statistics_kind ) ON column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ON ( expression ) , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ON ( expression ) , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind ) ON ( expression ) , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind ) ON ( expression ) , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind , statistics_kind ) ON ( expression ) , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind , statistics_kind ) ON ( expression ) , ( expression ) FROM table_name"),
+		Parses("CREATE STATISTICS statistics_name ON column_name , column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ON column_name , column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind ) ON column_name , column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind ) ON column_name , column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind , statistics_kind ) ON column_name , column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind , statistics_kind ) ON column_name , column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ON ( expression ) , column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ON ( expression ) , column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind ) ON ( expression ) , column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind ) ON ( expression ) , column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind , statistics_kind ) ON ( expression ) , column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind , statistics_kind ) ON ( expression ) , column_name , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ON column_name , ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ON column_name , ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind ) ON column_name , ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind ) ON column_name , ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind , statistics_kind ) ON column_name , ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind , statistics_kind ) ON column_name , ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ON ( expression ) , ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ON ( expression ) , ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind ) ON ( expression ) , ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind ) ON ( expression ) , ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind , statistics_kind ) ON ( expression ) , ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind , statistics_kind ) ON ( expression ) , ( expression ) , column_name FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ON column_name , column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ON column_name , column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind ) ON column_name , column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind ) ON column_name , column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind , statistics_kind ) ON column_name , column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind , statistics_kind ) ON column_name , column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ON ( expression ) , column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ON ( expression ) , column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind ) ON ( expression ) , column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind ) ON ( expression ) , column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind , statistics_kind ) ON ( expression ) , column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind , statistics_kind ) ON ( expression ) , column_name , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ON column_name , ( expression ) , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ON column_name , ( expression ) , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind ) ON column_name , ( expression ) , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind ) ON column_name , ( expression ) , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind , statistics_kind ) ON column_name , ( expression ) , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind , statistics_kind ) ON column_name , ( expression ) , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ON ( expression ) , ( expression ) , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ON ( expression ) , ( expression ) , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind ) ON ( expression ) , ( expression ) , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind ) ON ( expression ) , ( expression ) , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS statistics_name ( statistics_kind , statistics_kind ) ON ( expression ) , ( expression ) , ( expression ) FROM table_name"),
+		Unimplemented("CREATE STATISTICS IF NOT EXISTS statistics_name ( statistics_kind , statistics_kind ) ON ( expression ) , ( expression ) , ( expression ) FROM table_name"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_subscription_test.go

@@ -0,0 +1,37 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateSubscription(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE SUBSCRIPTION subscription_name CONNECTION ' conninfo ' PUBLICATION publication_name"),
+		Unimplemented("CREATE SUBSCRIPTION subscription_name CONNECTION ' conninfo ' PUBLICATION publication_name , publication_name"),
+		Unimplemented("CREATE SUBSCRIPTION subscription_name CONNECTION ' conninfo ' PUBLICATION publication_name WITH ( subscription_parameter )"),
+		Unimplemented("CREATE SUBSCRIPTION subscription_name CONNECTION ' conninfo ' PUBLICATION publication_name , publication_name WITH ( subscription_parameter )"),
+		Unimplemented("CREATE SUBSCRIPTION subscription_name CONNECTION ' conninfo ' PUBLICATION publication_name WITH ( subscription_parameter = value )"),
+		Unimplemented("CREATE SUBSCRIPTION subscription_name CONNECTION ' conninfo ' PUBLICATION publication_name , publication_name WITH ( subscription_parameter = value )"),
+		Unimplemented("CREATE SUBSCRIPTION subscription_name CONNECTION ' conninfo ' PUBLICATION publication_name WITH ( subscription_parameter , subscription_parameter )"),
+		Unimplemented("CREATE SUBSCRIPTION subscription_name CONNECTION ' conninfo ' PUBLICATION publication_name , publication_name WITH ( subscription_parameter , subscription_parameter )"),
+		Unimplemented("CREATE SUBSCRIPTION subscription_name CONNECTION ' conninfo ' PUBLICATION publication_name WITH ( subscription_parameter = value , subscription_parameter )"),
+		Unimplemented("CREATE SUBSCRIPTION subscription_name CONNECTION ' conninfo ' PUBLICATION publication_name , publication_name WITH ( subscription_parameter = value , subscription_parameter )"),
+		Unimplemented("CREATE SUBSCRIPTION subscription_name CONNECTION ' conninfo ' PUBLICATION publication_name WITH ( subscription_parameter , subscription_parameter = value )"),
+		Unimplemented("CREATE SUBSCRIPTION subscription_name CONNECTION ' conninfo ' PUBLICATION publication_name , publication_name WITH ( subscription_parameter , subscription_parameter = value )"),
+		Unimplemented("CREATE SUBSCRIPTION subscription_name CONNECTION ' conninfo ' PUBLICATION publication_name WITH ( subscription_parameter = value , subscription_parameter = value )"),
+		Unimplemented("CREATE SUBSCRIPTION subscription_name CONNECTION ' conninfo ' PUBLICATION publication_name , publication_name WITH ( subscription_parameter = value , subscription_parameter = value )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_tablespace_test.go

@@ -0,0 +1,38 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateTablespace(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE TABLESPACE tablespace_name LOCATION ' directory '"),
+		Unimplemented("CREATE TABLESPACE tablespace_name OWNER new_owner LOCATION ' directory '"),
+		Unimplemented("CREATE TABLESPACE tablespace_name OWNER CURRENT_ROLE LOCATION ' directory '"),
+		Unimplemented("CREATE TABLESPACE tablespace_name OWNER CURRENT_USER LOCATION ' directory '"),
+		Unimplemented("CREATE TABLESPACE tablespace_name OWNER SESSION_USER LOCATION ' directory '"),
+		Unimplemented("CREATE TABLESPACE tablespace_name LOCATION ' directory ' WITH ( tablespace_option = value )"),
+		Unimplemented("CREATE TABLESPACE tablespace_name OWNER new_owner LOCATION ' directory ' WITH ( tablespace_option = value )"),
+		Unimplemented("CREATE TABLESPACE tablespace_name OWNER CURRENT_ROLE LOCATION ' directory ' WITH ( tablespace_option = value )"),
+		Unimplemented("CREATE TABLESPACE tablespace_name OWNER CURRENT_USER LOCATION ' directory ' WITH ( tablespace_option = value )"),
+		Unimplemented("CREATE TABLESPACE tablespace_name OWNER SESSION_USER LOCATION ' directory ' WITH ( tablespace_option = value )"),
+		Unimplemented("CREATE TABLESPACE tablespace_name LOCATION ' directory ' WITH ( tablespace_option = value , value )"),
+		Unimplemented("CREATE TABLESPACE tablespace_name OWNER new_owner LOCATION ' directory ' WITH ( tablespace_option = value , value )"),
+		Unimplemented("CREATE TABLESPACE tablespace_name OWNER CURRENT_ROLE LOCATION ' directory ' WITH ( tablespace_option = value , value )"),
+		Unimplemented("CREATE TABLESPACE tablespace_name OWNER CURRENT_USER LOCATION ' directory ' WITH ( tablespace_option = value , value )"),
+		Unimplemented("CREATE TABLESPACE tablespace_name OWNER SESSION_USER LOCATION ' directory ' WITH ( tablespace_option = value , value )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_text_search_configuration_test.go

@@ -0,0 +1,25 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateTextSearchConfiguration(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE TEXT SEARCH CONFIGURATION name ( PARSER = parser_name )"),
+		Unimplemented("CREATE TEXT SEARCH CONFIGURATION name ( COPY = source_config )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_text_search_dictionary_test.go

@@ -0,0 +1,26 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateTextSearchDictionary(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE TEXT SEARCH DICTIONARY name ( TEMPLATE = template )"),
+		Unimplemented("CREATE TEXT SEARCH DICTIONARY name ( TEMPLATE = template , option = value )"),
+		Unimplemented("CREATE TEXT SEARCH DICTIONARY name ( TEMPLATE = template , option = value , option = value )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_text_search_parser_test.go

@@ -0,0 +1,25 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateTextSearchParser(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE TEXT SEARCH PARSER name ( START = start_function , GETTOKEN = gettoken_function , END = end_function , LEXTYPES = lextypes_function )"),
+		Unimplemented("CREATE TEXT SEARCH PARSER name ( START = start_function , GETTOKEN = gettoken_function , END = end_function , LEXTYPES = lextypes_function , HEADLINE = headline_function )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_text_search_template_test.go

@@ -0,0 +1,25 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateTextSearchTemplate(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE TEXT SEARCH TEMPLATE name ( LEXIZE = lexize_function )"),
+		Unimplemented("CREATE TEXT SEARCH TEMPLATE name ( INIT = init_function , LEXIZE = lexize_function )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_transform_test.go

@@ -0,0 +1,41 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateTransform(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name , TO SQL WITH FUNCTION to_sql_function_name )"),
+		Unimplemented("CREATE OR REPLACE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name , TO SQL WITH FUNCTION to_sql_function_name )"),
+		Unimplemented("CREATE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name ( argument_type ) , TO SQL WITH FUNCTION to_sql_function_name )"),
+		Unimplemented("CREATE OR REPLACE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name ( argument_type ) , TO SQL WITH FUNCTION to_sql_function_name )"),
+		Unimplemented("CREATE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name ( argument_type , argument_type ) , TO SQL WITH FUNCTION to_sql_function_name )"),
+		Unimplemented("CREATE OR REPLACE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name ( argument_type , argument_type ) , TO SQL WITH FUNCTION to_sql_function_name )"),
+		Unimplemented("CREATE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name , TO SQL WITH FUNCTION to_sql_function_name ( argument_type ) )"),
+		Unimplemented("CREATE OR REPLACE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name , TO SQL WITH FUNCTION to_sql_function_name ( argument_type ) )"),
+		Unimplemented("CREATE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name ( argument_type ) , TO SQL WITH FUNCTION to_sql_function_name ( argument_type ) )"),
+		Unimplemented("CREATE OR REPLACE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name ( argument_type ) , TO SQL WITH FUNCTION to_sql_function_name ( argument_type ) )"),
+		Unimplemented("CREATE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name ( argument_type , argument_type ) , TO SQL WITH FUNCTION to_sql_function_name ( argument_type ) )"),
+		Unimplemented("CREATE OR REPLACE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name ( argument_type , argument_type ) , TO SQL WITH FUNCTION to_sql_function_name ( argument_type ) )"),
+		Unimplemented("CREATE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name , TO SQL WITH FUNCTION to_sql_function_name ( argument_type , argument_type ) )"),
+		Unimplemented("CREATE OR REPLACE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name , TO SQL WITH FUNCTION to_sql_function_name ( argument_type , argument_type ) )"),
+		Unimplemented("CREATE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name ( argument_type ) , TO SQL WITH FUNCTION to_sql_function_name ( argument_type , argument_type ) )"),
+		Unimplemented("CREATE OR REPLACE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name ( argument_type ) , TO SQL WITH FUNCTION to_sql_function_name ( argument_type , argument_type ) )"),
+		Unimplemented("CREATE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name ( argument_type , argument_type ) , TO SQL WITH FUNCTION to_sql_function_name ( argument_type , argument_type ) )"),
+		Unimplemented("CREATE OR REPLACE TRANSFORM FOR type_name LANGUAGE lang_name ( FROM SQL WITH FUNCTION from_sql_function_name ( argument_type , argument_type ) , TO SQL WITH FUNCTION to_sql_function_name ( argument_type , argument_type ) )"),
+	}
+	RunTests(t, tests)
+}

testing/generation/command_docs/output/create_user_mapping_test.go

@@ -0,0 +1,53 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package output
+
+import "testing"
+
+func TestCreateUserMapping(t *testing.T) {
+	tests := []QueryParses{
+		Unimplemented("CREATE USER MAPPING FOR user_name SERVER server_name"),
+		Unimplemented("CREATE USER MAPPING IF NOT EXISTS FOR user_name SERVER server_name"),
+		Unimplemented("CREATE USER MAPPING FOR USER SERVER server_name"),
+		Unimplemented("CREATE USER MAPPING IF NOT EXISTS FOR USER SERVER server_name"),
+		Unimplemented("CREATE USER MAPPING FOR CURRENT_ROLE SERVER server_name"),
+		Unimplemented("CREATE USER MAPPING IF NOT EXISTS FOR CURRENT_ROLE SERVER server_name"),
+		Unimplemented("CREATE USER MAPPING FOR CURRENT_USER SERVER server_name"),
+		Unimplemented("CREATE USER MAPPING IF NOT EXISTS FOR CURRENT_USER SERVER server_name"),
+		Unimplemented("CREATE USER MAPPING FOR PUBLIC SERVER server_name"),
+		Unimplemented("CREATE USER MAPPING IF NOT EXISTS FOR PUBLIC SERVER server_name"),
+		Unimplemented("CREATE USER MAPPING FOR user_name SERVER server_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING IF NOT EXISTS FOR user_name SERVER server_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING FOR USER SERVER server_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING IF NOT EXISTS FOR USER SERVER server_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING FOR CURRENT_ROLE SERVER server_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING IF NOT EXISTS FOR CURRENT_ROLE SERVER server_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING FOR CURRENT_USER SERVER server_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING IF NOT EXISTS FOR CURRENT_USER SERVER server_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING FOR PUBLIC SERVER server_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING IF NOT EXISTS FOR PUBLIC SERVER server_name OPTIONS ( option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING FOR user_name SERVER server_name OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING IF NOT EXISTS FOR user_name SERVER server_name OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING FOR USER SERVER server_name OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING IF NOT EXISTS FOR USER SERVER server_name OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING FOR CURRENT_ROLE SERVER server_name OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING IF NOT EXISTS FOR CURRENT_ROLE SERVER server_name OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING FOR CURRENT_USER SERVER server_name OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING IF NOT EXISTS FOR CURRENT_USER SERVER server_name OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING FOR PUBLIC SERVER server_name OPTIONS ( option ' value ' , option ' value ' )"),
+		Unimplemented("CREATE USER MAPPING IF NOT EXISTS FOR PUBLIC SERVER server_name OPTIONS ( option ' value ' , option ' value ' )"),
+	}
+	RunTests(t, tests)
+}