org.jooq.impl.QOM Maven / Gradle / Ivy
/*
* 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.
*
* Other licenses:
* -----------------------------------------------------------------------------
* Commercial licenses for this work are available. These replace the above
* Apache-2.0 license and offer limited warranties, support, maintenance, and
* commercial database integrations.
*
* For more information, please visit: http://www.jooq.org/licenses
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package org.jooq.impl;
import static java.util.Collections.unmodifiableCollection;
import static java.util.Collections.unmodifiableList;
import static org.jooq.impl.DSL.keyword;
import java.math.BigDecimal;
import java.sql.Date;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.UUID;
import java.util.function.Predicate;
// ...
import org.jooq.Catalog;
import org.jooq.Collation;
import org.jooq.Comment;
import org.jooq.CommonTableExpression;
import org.jooq.Condition;
import org.jooq.Constraint;
import org.jooq.DDLQuery;
import org.jooq.DMLQuery;
import org.jooq.DataType;
import org.jooq.DatePart;
import org.jooq.Domain;
import org.jooq.Field;
import org.jooq.FieldOrRow;
import org.jooq.Function1;
import org.jooq.Function10;
import org.jooq.Function11;
import org.jooq.Function12;
import org.jooq.Function13;
import org.jooq.Function14;
import org.jooq.Function15;
import org.jooq.Function16;
import org.jooq.Function17;
import org.jooq.Function18;
import org.jooq.Function19;
import org.jooq.Function2;
import org.jooq.Function20;
import org.jooq.Function21;
import org.jooq.Function22;
import org.jooq.Function3;
import org.jooq.Function4;
import org.jooq.Function5;
import org.jooq.Function6;
import org.jooq.Function7;
import org.jooq.Function8;
import org.jooq.Function9;
import org.jooq.Geometry;
import org.jooq.GroupField;
import org.jooq.Index;
import org.jooq.JSONEntry;
import org.jooq.Keyword;
// ...
import org.jooq.Name;
import org.jooq.OrderField;
import org.jooq.Param;
import org.jooq.Parameter;
import org.jooq.Privilege;
// ...
import org.jooq.Query;
import org.jooq.QueryPart;
import org.jooq.Record;
import org.jooq.Record1;
// ...
import org.jooq.Result;
import org.jooq.ResultQuery;
import org.jooq.Role;
import org.jooq.Row;
import org.jooq.RowCountQuery;
import org.jooq.RowId;
import org.jooq.SQL;
import org.jooq.SQLDialect;
import org.jooq.Schema;
import org.jooq.Select;
import org.jooq.Sequence;
import org.jooq.Spatial;
import org.jooq.Statement;
import org.jooq.Table;
import org.jooq.TableElement;
import org.jooq.TableLike;
// ...
// ...
import org.jooq.WindowDefinition;
import org.jooq.WindowSpecification;
import org.jooq.XML;
import org.jooq.XMLAttributes;
import org.jooq.conf.Settings;
import org.jooq.types.DayToSecond;
// ...
import org.jetbrains.annotations.ApiStatus.Experimental;
import org.jetbrains.annotations.ApiStatus.Internal;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
* A draft of the new query object model API.
*
* This API is EXPERIMENTAL. Use at your own risk.
*
*
Purpose
*
* This class provides a single namespace for jOOQ's query object model API.
* Every {@link QueryPart} from the DSL API has a matching {@link QueryPart}
* representation in this query object model API, and a shared internal
* implementation in the org.jooq.impl package, that covers both
* the DSL and model API functionality.
*
* The goal of this model API is to allow for expression tree transformations
* via {@link QueryPart#$replace(Function1)} as well as via per-querypart
* methods, such as for example {@link Substring#$startingPosition(Field)}, and
* traversals via {@link QueryPart#$traverse(Traverser)} that are independent of
* the DSL API that would otherwise be too noisy for this task.
*
*
Design
*
* In order to avoid conflicts between the model API and the DSL API, all model
* API in this class follows these naming conventions:
*
* - All public model API types are nested in the {@link QOM} class, whereas
* DSL API types are top level types in the
org.jooq package.
* - All accessor methods and their corresponding "immutable setters"
* (returning a copy containing the modification) are named
*
$property(), e.g. {@link Substring#$startingPosition()} and
* {@link Substring#$startingPosition(Field)}.
* - All private model API utility types are named
UXyz, e.g.
* {@link UEmpty}
*
*
*
Limitations
*
* The API offers public access to jOOQ's internal representation, and as such,
* is prone to incompatible changes between minor releases, in addition to the
* incompatible changes that may arise due to this API being experimental. In
* this experimental stage, the following limitations are accepted:
*
* - Not all {@link QueryPart} implementations have a corresponding public
* {@link QueryPart} type yet, but may just implement the API via a
* {@link UEmpty} or {@link UNotYetImplemented} subtype, and may not provide
* access to contents via accessor methods.
* - Some child elements of a {@link QueryPart} may not yet be represented in
* the model API, such as for example the
SELECT … FOR UPDATE
* clause, as substantial changes to the internal model are still required
* before being able to offer public access to it.
*
*
*
Mutability
*
* While some elements of this API are historically mutable (either mutable
* objects are returned from {@link QueryPart} subtypes, or argument objects
* when constructing an {@link QueryPart} remains mutable, rather than copied),
* users must not rely on this mutable behaviour. Once this API stabilises, all
* mutability will be gone, accidental remaining mutability will be considered a
* bug.
*
*
Notes
*
* A future Java 17 distribution of jOOQ might make use of sealed types to
* improve the usability of the model API in pattern matching expressions etc.
* Other Java language features that benefit pattern matching expression trees
* might be adopted in the future in this area of the jOOQ API.
*
* @author Lukas Eder
*/
@Experimental
public final class QOM {
// -------------------------------------------------------------------------
// XXX: Model
// -------------------------------------------------------------------------
// This class uses a lot of fully qualified types, because of some javac bug
// In Java 1.8.0_302, which hasn't been analysed and reproduced yet in a more
// minimal example. Without the qualification, the types cannot be found
// despite being imported
/**
* An unmodifiable {@link Collection} of {@link QueryPart} elements.
*/
public sealed interface UnmodifiableCollection
extends
org.jooq.QueryPart,
java.util.Collection
permits
UnmodifiableList,
QueryPartCollectionView
{}
/**
* An unmodifiable {@link List} of {@link QueryPart} elements.
*/
public sealed interface UnmodifiableList
extends
UnmodifiableCollection,
java.util.List
permits
QueryPartListView
{}
public /*sealed*/ interface With
extends
org.jooq.QueryPart
/*permits
WithImpl*/
{
@NotNull UnmodifiableList> $commonTableExpressions();
boolean $recursive();
}
// -------------------------------------------------------------------------
// XXX: Queries
// -------------------------------------------------------------------------
public /*sealed*/ interface CreateType
extends
DDLQuery
/*permits
CreateTypeImpl*/
{
@NotNull Name $name();
@NotNull UnmodifiableList> $values();
}
public /*sealed*/ interface DropType
extends
DDLQuery
/*permits
DropTypeImpl*/
{
@NotNull UnmodifiableList $names();
boolean $ifExists();
@Nullable Cascade $cascade();
}
public /*sealed*/ interface CreateView
extends
DDLQuery
/*permits
CreateViewImpl*/
{
boolean $ifNotExists();
boolean $orReplace();
@NotNull Table $view();
@NotNull UnmodifiableList> $fields();
@NotNull ResultQuery $query();
}
// -------------------------------------------------------------------------
// XXX: Schema
// -------------------------------------------------------------------------
public interface PrimaryKey extends Constraint {
@NotNull UnmodifiableList> $fields();
}
public interface UniqueKey extends Constraint {
@NotNull UnmodifiableList> $fields();
}
public interface ForeignKey extends Constraint {
@NotNull UnmodifiableList> $fields();
@NotNull Constraint $references();
}
public interface Check extends Constraint {
@NotNull Condition $condition();
}
// -------------------------------------------------------------------------
// XXX: Statements
// -------------------------------------------------------------------------
public interface NullStatement extends Statement {}
// -------------------------------------------------------------------------
// XXX: Tables
// -------------------------------------------------------------------------
public interface TableAlias extends Table {
@NotNull Table $table();
@NotNull Name $alias();
// TODO [#12425] Reuse MDerivedColumnList
}
public interface Dual extends Table, UEmpty {}
public interface Lateral extends Table, UOperator1, Table> {}
public interface DerivedTable extends Table, UOperator1, Table> {}
public interface Values extends Table, UOperator1, Table> {}
public interface DataChangeDeltaTable extends Table {
@NotNull ResultOption $resultOption();
@NotNull DMLQuery $query();
}
public interface RowsFrom extends Table {
@NotNull UnmodifiableList> $tables();
}
public interface GenerateSeries extends Table>, UOperator3, Field, Field, Table>> {
@NotNull default Field $from() { return $arg1(); }
@NotNull default Field $to() { return $arg2(); }
@Nullable default Field $step() { return $arg3(); }
}
// -------------------------------------------------------------------------
// XXX: Conditions
// -------------------------------------------------------------------------
public /*sealed*/ interface CombinedCondition
extends
Condition,
UCommutativeOperator
/*permits
MAnd,
MOr*/
{}
public /*sealed*/ interface CompareCondition
extends
Condition,
UOperator2, Field, Condition>
/*permits
MEq,
MNe,
MLt,
MLe,
MGt,
MGe,
MIsDistinctFrom,
MIsNotDistinctFrom,
MContains,
MContainsIgnoreCase,
MStartsWith,
MStartsWithIgnoreCase,
MEndsWith,
MEndsWithIgnoreCase*/
{}
public interface Between extends UOperator3, Field, Field, Condition> {
boolean $symmetric();
}
public /*sealed*/ interface InList
extends
Condition,
UOperator2, UnmodifiableList>, Condition>
/*permits
InList*/
{
@NotNull default Field $field() { return $arg1(); }
@NotNull default UnmodifiableList> $list() { return $arg2(); }
}
public /*sealed*/ interface NotInList
extends
Condition,
UOperator2, UnmodifiableList>, Condition>
/*permits
NotInList*/
{
@NotNull default Field $field() { return $arg1(); }
@NotNull default UnmodifiableList> $list() { return $arg2(); }
}
public /*sealed*/ interface RegexpLike
extends
Condition
/*permits
RegexpLike*/
{
@NotNull Field $search();
@NotNull Field $pattern();
}
public /*sealed*/ interface Extract
extends
Field
/*permits
Extract*/
{
@NotNull Field $field();
@NotNull DatePart $datePart();
}
public /*sealed*/ interface RowIsNull
extends
Condition,
UOperator1
/*permits
RowIsNull*/
{
@NotNull default Row $field() { return $arg1(); }
}
public /*sealed*/ interface RowIsNotNull
extends
Condition,
UOperator1
/*permits
RowIsNotNull*/
{
@NotNull default Row $field() { return $arg1(); }
}
public /*sealed*/ interface RowOverlaps
extends
Condition,
UOperator2
/*permits
RowOverlaps*/
{}
public /*sealed*/ interface SelectIsNull
extends
Condition,
UOperator1, Condition>
/*permits
SelectIsNull*/
{
@NotNull default Select $field() { return $arg1(); }
}
public /*sealed*/ interface SelectIsNotNull
extends
Condition,
UOperator1, Condition>
/*permits
SelectIsNotNull*/
{
@NotNull default Select $field() { return $arg1(); }
}
// -------------------------------------------------------------------------
// XXX: Rows
// -------------------------------------------------------------------------
public /*sealed*/ interface RowAsField
extends
org.jooq.Field
/*permits
RowAsField*/
{
@NotNull Row $row();
}
public /*sealed*/ interface TableAsField
extends
org.jooq.Field
/*permits
TableAsField*/
{
@NotNull Table $table();
}
// -------------------------------------------------------------------------
// XXX: SelectFields, GroupFields and SortFields
// -------------------------------------------------------------------------
// Can't seal these types yet because of https://bugs.eclipse.org/bugs/show_bug.cgi?id=577872
public non-sealed interface EmptyGroupingSet
extends
GroupField,
UEmpty
/*permits
org.jooq.impl.EmptyGroupingSet*/
{}
public non-sealed interface Rollup
extends
GroupField,
UOperator1, GroupField>
/*permits
Rollup*/
{}
public non-sealed interface Cube
extends
GroupField,
UOperator1, GroupField>
/*permits
Cube*/
{}
public non-sealed interface GroupingSets
extends
GroupField,
UOperator1>, GroupField>
/*permits
GroupingSets*/
{}
// -------------------------------------------------------------------------
// XXX: Aggregate functions and window functions
// -------------------------------------------------------------------------
public /*sealed*/ interface RatioToReport
extends
org.jooq.AggregateFunction
/*permits
RatioToReport*/
{
@NotNull Field $field();
}
public /*sealed*/ interface Mode
extends
org.jooq.AggregateFunction,
UOperator1, org.jooq.AggregateFunction>
/*permits
Mode*/
{
@NotNull default Field $field() { return $arg1(); }
}
public /*sealed*/ interface MultisetAgg
extends
org.jooq.AggregateFunction>
/*permits
MultisetAgg*/
{
@NotNull Row $row();
}
public /*sealed*/ interface ArrayAgg
extends
org.jooq.AggregateFunction,
UOperator1, org.jooq.AggregateFunction>
/*permits
ArrayAgg*/
{
@NotNull default Field $field() { return $arg1(); }
boolean $distinct();
}
public /*sealed*/ interface XMLAgg
extends
org.jooq.AggregateFunction,
UOperator1, org.jooq.AggregateFunction>
/*permits
XMLAgg*/
{
@NotNull default Field $field() { return $arg1(); }
}
public /*sealed*/ interface JSONArrayAgg
extends
org.jooq.AggregateFunction,
UOperator1, org.jooq.AggregateFunction>
/*permits
JSONArrayAgg*/
{
@NotNull default Field $field() { return $arg1(); }
@Nullable JSONOnNull $onNull();
@Nullable DataType $returning();
}
public /*sealed*/ interface JSONObjectAgg
extends
org.jooq.AggregateFunction,
UOperator1, org.jooq.AggregateFunction>
/*permits JSONObjectAgg*/
{
@NotNull default JSONEntry $entry() { return $arg1(); }
@Nullable JSONOnNull $onNull();
@Nullable DataType $returning();
}
public /*sealed*/ interface CountTable
extends
org.jooq.AggregateFunction
/*permits
CountTable*/
{
@NotNull Table $table();
boolean $distinct();
}
public interface WindowFunction extends org.jooq.Field {
@Nullable WindowSpecification $windowSpecification();
@Nullable WindowDefinition $windowDefinition();
}
public /*sealed*/ interface RowNumber
extends
WindowFunction
/*permits
RowNumber*/
{}
public /*sealed*/ interface Rank
extends
WindowFunction
/*permits
Rank*/
{}
public /*sealed*/ interface DenseRank
extends
WindowFunction
/*permits
DenseRank*/
{}
public /*sealed*/ interface PercentRank
extends
WindowFunction
/*permits
PercentRank*/
{}
public /*sealed*/ interface CumeDist
extends
WindowFunction
/*permits
CumeDist*/
{}
public /*sealed*/ interface Ntile
extends
WindowFunction
/*permits Ntile*/
{
@NotNull Field $tiles();
}
public /*sealed*/ interface Lead
extends
WindowFunction
/*permits
Lead*/
{
@NotNull Field $field();
@Nullable Field $offset();
@Nullable Field $defaultValue();
@Nullable NullTreatment $nullTreatment();
}
public /*sealed*/ interface Lag
extends
WindowFunction
/*permits
Lag*/
{
@NotNull Field $field();
@Nullable Field $offset();
@Nullable Field $defaultValue();
@Nullable NullTreatment $nullTreatment();
}
public /*sealed*/ interface FirstValue
extends
WindowFunction
/*permits
FirstValue*/
{
@NotNull Field $field();
@Nullable NullTreatment $nullTreatment();
}
public /*sealed*/ interface LastValue
extends
WindowFunction
/*permits
LastValue*/
{
@NotNull Field $field();
@Nullable NullTreatment $nullTreatment();
}
public /*sealed*/ interface NthValue
extends
WindowFunction
/*permits
NthValue*/
{
@NotNull Field $field();
@Nullable FromFirstOrLast $fromFirstOrLast();
@Nullable NullTreatment $nullTreatment();
}
// -------------------------------------------------------------------------
// XXX: Fields
// -------------------------------------------------------------------------
public /*sealed*/ interface FieldAlias
extends
Field
/*permits
FieldAlias*/
{
@NotNull Field $field();
@NotNull Name $alias();
}
public /*sealed*/ interface Function
extends
Field
/*permits
org.jooq.impl.Function,
org.jooq.impl.Function1*/
{
@NotNull UnmodifiableList> $args();
}
public /*sealed*/ interface Cast
extends
Field
/*permits
Cast*/
{
@NotNull Field $field();
}
public /*sealed*/ interface Coerce
extends
Field
/*permits
Coerce*/
{
@NotNull Field $field();
}
public /*sealed*/ interface Default
extends
Field,
UEmpty
/*permits
Default*/
{}
public /*sealed*/ interface Collated
extends
Field
/*permits
Collated*/
{
@NotNull Field $field();
@NotNull Collation $collation();
}
public /*sealed*/ interface Array
extends
Field
/*permits
org.jooq.impl.Array*/
{
@NotNull UnmodifiableList> $elements();
}
public /*sealed*/ interface ArrayQuery
extends
Field
/*permits
ArrayQuery*/
{
@NotNull Select> $select();
}
public /*sealed*/ interface Multiset
extends
org.jooq.Field>
/*permits
Multiset*/
{
@NotNull TableLike $table();
}
public /*sealed*/ interface ScalarSubquery
extends
Field,
UOperator1>, Field>
/*permits
ScalarSubquery*/
{}
public /*sealed*/ interface Neg
extends
Field,
UOperator1, Field>
/*permits
Neg*/
{}
public /*sealed*/ interface Greatest
extends
Field,
UOperator1>, Field>
/*permits
Greatest*/
{}
public /*sealed*/ interface Least
extends
Field,
UOperator1>, Field>
/*permits
Least*/
{}
public /*sealed*/ interface Choose
extends
Field,
UOperator2, UnmodifiableList>, Field>
/*permits
Choose*/
{}
public /*sealed*/ interface FieldFunction
extends
Field,
UOperator2, UnmodifiableList>, Field>
/*permits
FieldFunction*/
{}
public /*sealed*/ interface Nvl2
extends
Field,
UOperator3, Field, Field, Field>
/*permits
Nvl2*/
{
@NotNull default Field $value() { return $arg1(); }
@NotNull default Field $ifNotNull() { return $arg2(); }
@NotNull default Field $ifIfNull() { return $arg3(); }
}
public /*sealed*/ interface Iif
extends
Field,
UOperator3, Field, Field>
/*permits
Iif*/
{
@NotNull default Condition $condition() { return $arg1(); }
@NotNull default Field $ifTrue() { return $arg2(); }
@NotNull default Field $ifFalse() { return $arg3(); }
}
public /*sealed*/ interface Coalesce
extends
Field,
UOperator1>, Field>
/*permits
Coalesce*/
{}
public /*sealed*/ interface Concat
extends
Field,
UOperator1>, Field>
/*permits
Concat*/
{}
public /*sealed*/ interface TimestampDiff
extends
Field,
UOperator2, Field, Field>
/*permits
TimestampDiff*/
{
@NotNull default Field $minuend() { return $arg1(); }
@NotNull default Field $subtrahend() { return $arg2(); }
}
public /*sealed*/ interface Convert
extends
Field
/*permits
ConvertDateTime*/
{
@NotNull Field $field();
int $style();
}
public /*sealed*/ interface CurrentDate
extends
Field,
UEmpty
/*permits
CurrentDate*/
{}
public /*sealed*/ interface CurrentTime
extends
Field,
UEmpty
/*permits
CurrentTime*/
{}
public /*sealed*/ interface CurrentTimestamp
extends
Field,
UEmpty
/*permits
CurrentTimestamp*/
{}
public /*sealed*/ interface XMLQuery
extends
Field
/*permits
XMLQuery*/
{
@NotNull Field $xpath();
@NotNull Field $passing();
@Nullable XMLPassingMechanism $passingMechanism();
}
public /*sealed*/ interface XMLElement
extends
Field
/*permits
XMLElement*/
{
@NotNull Name $elementName();
@NotNull XMLAttributes $attributes();
@NotNull UnmodifiableList> $content();
}
public /*sealed*/ interface XMLExists
extends
Condition
/*permits
XMLExists*/
{
@NotNull Field $xpath();
@NotNull Field $passing();
@Nullable XMLPassingMechanism $passingMechanism();
}
public /*sealed*/ interface XMLParse
extends
Field
/*permits
XMLParse*/
{
@NotNull Field $content();
@NotNull DocumentOrContent $documentOrContent();
}
/**
* The ALTER DATABASE statement.
*/
public /*sealed*/ interface AlterDatabase
extends
DDLQuery
//permits
// AlterDatabaseImpl
{
@NotNull Catalog $database();
boolean $ifExists();
@NotNull Catalog $renameTo();
@NotNull AlterDatabase $database(Catalog database);
@NotNull AlterDatabase $ifExists(boolean ifExists);
@NotNull AlterDatabase $renameTo(Catalog renameTo);
}
/**
* The ALTER DOMAIN statement.
*/
public /*sealed*/ interface AlterDomain
extends
DDLQuery
//permits
// AlterDomainImpl
{
@NotNull Domain $domain();
boolean $ifExists();
@Nullable Constraint $addConstraint();
@Nullable Constraint $dropConstraint();
boolean $dropConstraintIfExists();
@Nullable Domain $renameTo();
@Nullable Constraint $renameConstraint();
boolean $renameConstraintIfExists();
@Nullable Field $setDefault();
boolean $dropDefault();
boolean $setNotNull();
boolean $dropNotNull();
@Nullable Cascade $cascade();
@Nullable Constraint $renameConstraintTo();
@NotNull AlterDomain $domain(Domain domain);
@NotNull AlterDomain $ifExists(boolean ifExists);
@NotNull AlterDomain $addConstraint(Constraint addConstraint);
@NotNull AlterDomain $dropConstraint(Constraint dropConstraint);
@NotNull AlterDomain $dropConstraintIfExists(boolean dropConstraintIfExists);
@NotNull AlterDomain $renameTo(Domain renameTo);
@NotNull AlterDomain $renameConstraint(Constraint renameConstraint);
@NotNull AlterDomain $renameConstraintIfExists(boolean renameConstraintIfExists);
@NotNull AlterDomain $setDefault(Field setDefault);
@NotNull AlterDomain $dropDefault(boolean dropDefault);
@NotNull AlterDomain $setNotNull(boolean setNotNull);
@NotNull AlterDomain $dropNotNull(boolean dropNotNull);
@NotNull AlterDomain $cascade(Cascade cascade);
@NotNull AlterDomain $renameConstraintTo(Constraint renameConstraintTo);
}
/**
* The ALTER INDEX statement.
*/
public /*sealed*/ interface AlterIndex
extends
DDLQuery
//permits
// AlterIndexImpl
{
@NotNull Index $index();
boolean $ifExists();
@Nullable Table $on();
@NotNull Index $renameTo();
@NotNull AlterIndex $index(Index index);
@NotNull AlterIndex $ifExists(boolean ifExists);
@NotNull AlterIndex $on(Table on);
@NotNull AlterIndex $renameTo(Index renameTo);
}
/**
* The ALTER SCHEMA statement.
*/
public /*sealed*/ interface AlterSchema
extends
DDLQuery
//permits
// AlterSchemaImpl
{
@NotNull Schema $schema();
boolean $ifExists();
@NotNull Schema $renameTo();
@NotNull AlterSchema $schema(Schema schema);
@NotNull AlterSchema $ifExists(boolean ifExists);
@NotNull AlterSchema $renameTo(Schema renameTo);
}
/**
* The ALTER SEQUENCE statement.
*/
public /*sealed*/ interface AlterSequence
extends
DDLQuery
//permits
// AlterSequenceImpl
{
@NotNull Sequence $sequence();
boolean $ifExists();
@Nullable Sequence $renameTo();
boolean $restart();
@Nullable Field $restartWith();
@Nullable Field $startWith();
@Nullable Field $incrementBy();
@Nullable Field $minvalue();
boolean $noMinvalue();
@Nullable Field $maxvalue();
boolean $noMaxvalue();
@Nullable CycleOption $cycle();
@Nullable Field $cache();
boolean $noCache();
@NotNull AlterSequence $sequence(Sequence sequence);
@NotNull AlterSequence $ifExists(boolean ifExists);
@NotNull AlterSequence $renameTo(Sequence renameTo);
@NotNull AlterSequence $restart(boolean restart);
@NotNull AlterSequence $restartWith(Field restartWith);
@NotNull AlterSequence $startWith(Field startWith);
@NotNull AlterSequence $incrementBy(Field incrementBy);
@NotNull AlterSequence $minvalue(Field minvalue);
@NotNull AlterSequence $noMinvalue(boolean noMinvalue);
@NotNull AlterSequence $maxvalue(Field