gudusoft.gsqlparser.catalog.runtime

Class CatalogNameGrammar

Object

gudusoft.gsqlparser.catalog.runtime.CatalogNameGrammar

public final class CatalogNameGrammar
extends Object

Whole-shape validation of a catalog name (stage S0R of docs/refactor/identifier_identity_display_separation_plan.md).

Why whole-shape, and why two entry points

A pairwise "may this role follow that one" predicate cannot express the rules that matter — at most one of each container, the terminal agreeing with the declared kind, kind-dependent nesting, and above all whether the name is COMPLETE. Completeness is not a property of adjacent pairs; it is a property of the component list measured against the topology the namespace declares.

A resolved IDENTITY and a LOOKUP are different languages. A lookup may omit levels — t, s.t and db..t are all normal. An identity may not: every level its topology declares must be named, because an unresolved level inside a key silently binds to whatever the session default happened to be, and then collides with the same name in another schema.

Method Summary

Modifier and Type	Method and Description
static boolean	isObjectKind(CatalogObjectKind kind) Whether a kind may be carried by an OBJECT component.
static boolean	isRelation(CatalogObjectKind kind) Whether this kind owns columns.
static boolean	mayContainObject(CatalogObjectKind container, CatalogObjectKind child) Whether container may directly contain child as an object — the ONE transition table, shared by resolved identities and lookups so the two cannot disagree about what nests.
static CatalogParentConstraint	nestedParentFamilyFor(CatalogObjectKind childKind) The family a NESTED object of this kind must have as its parent.
static CatalogParentConstraint	parentConstraintFor(CatalogObjectKind childKind) Deprecated. renamed to nestedParentFamilyFor(gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind), which says what it actually answers.
static void	validateLookup(List<CatalogLookupName.Slot> slots, CatalogObjectKind terminalKind, CatalogHierarchy hierarchy, String databaseLink, IdentifierInputForm linkForm, CatalogParentConstraint parentConstraint) Validates a LOOKUP.
static void	validateResolvedIdentity(List<IdentifierComponentRole> roles, List<CatalogObjectKind> kinds, CatalogObjectKind terminalKind, CatalogHierarchy hierarchy) Validates a RESOLVED identity: legal roles, legal nesting, and COMPLETE against the declared topology.

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

isRelation

public static boolean isRelation(CatalogObjectKind kind)

Whether this kind owns columns.

isObjectKind

public static boolean isObjectKind(CatalogObjectKind kind)

Whether a kind may be carried by an OBJECT component.

mayContainObject

public static boolean mayContainObject(CatalogObjectKind container,
                                       CatalogObjectKind child)

Whether container may directly contain child as an object — the ONE transition table, shared by resolved identities and lookups so the two cannot disagree about what nests.

nestedParentFamilyFor

public static CatalogParentConstraint nestedParentFamilyFor(CatalogObjectKind childKind)

The family a NESTED object of this kind must have as its parent.

This does not decide whether the object IS nested. That is a property of the name's shape, not of the kind: a FUNCTION may sit directly in a schema or inside a package, and an INDEX may be named at schema level or under its relation. An earlier version used this method to decide existence, which rejected every schema-level function and — because a TABLE is not a "child kind" — accepted PACKAGE.TABLE without ever examining the extra component.

Returns:

the required family, or null when no nesting of this kind is modelled

parentConstraintFor

@Deprecated
public static CatalogParentConstraint parentConstraintFor(CatalogObjectKind childKind)

Deprecated. renamed to nestedParentFamilyFor(gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind), which says what it actually answers.

validateResolvedIdentity

public static void validateResolvedIdentity(List<IdentifierComponentRole> roles,
                                            List<CatalogObjectKind> kinds,
                                            CatalogObjectKind terminalKind,
                                            CatalogHierarchy hierarchy)

Validates a RESOLVED identity: legal roles, legal nesting, and COMPLETE against the declared topology.

Parameters:

roles - one role per component, outermost first

kinds - the entity kind at each position; null except at OBJECT positions

terminalKind - what the name denotes as a whole

hierarchy - which container levels the namespace HAS — declared by the caller, because the component list cannot distinguish "this dialect has no schema" from "the schema was not resolved"

Throws:

IllegalArgumentException - naming the first rule broken

validateLookup

public static void validateLookup(List<CatalogLookupName.Slot> slots,
                                  CatalogObjectKind terminalKind,
                                  CatalogHierarchy hierarchy,
                                  String databaseLink,
                                  IdentifierInputForm linkForm,
                                  CatalogParentConstraint parentConstraint)

Validates a LOOKUP. Unlike the identity form it accepts omissions, but it still has to be a name that could denote something: the slots must be in hierarchy order, each role may appear once, every applicable level must have an explicit state, a PRESENT slot must actually carry text and provenance, and the terminal must be PRESENT and agree with what is being sought.

The previous version of this method received only a list of slot STATES, so it could check nothing but "is something present" — it admitted a schema before a catalog, a duplicate catalog, OBJECT(TABLE) under terminal PROCEDURE, and an omitted terminal.

Parameters:

slots - the slots, outermost first

terminalKind - what is being looked for

hierarchy - the declared topology

databaseLink - the link text, or null

linkForm - the link's provenance; required when the link is present