接口的使用
jaskell.script.Directive

使用Directive的程序包

程序包	说明
jaskell.script
jaskell.sql

jaskell.script中Directive的使用

实现Directive的jaskell.script中的类

修饰符和类型	类	说明
class	Parameter<T>

jaskell.sql中Directive的使用

jaskell.sql中Directive的子接口

修饰符和类型	接口	说明
interface	CouldAlias	TODO
interface	CouldFrom	TODO
interface	CouldGroup	TODO
interface	CouldHaving	TODO
interface	CouldLimit	TODO
interface	CouldOffset	TODO
interface	CouldOrder	TODO
interface	CouldReturning	TODO
interface	CouldUnion	TODO
interface	From	TODO
interface	ThenSelect

实现Directive的jaskell.sql中的类

修饰符和类型	类	说明
class	Alias
class	And
class	Binary
class	Brackets
class	By
class	Case
static class	Case.Alias
static class	Case.Else
static class	Case.End
static class	Case.Then
static class	Case.When
class	Coalesce
class	Conflict
static class	Conflict.Constraint
static class	Conflict.On
static class	Conflict.Where
class	Count
class	Cross
class	Delete
static class	Delete.From
static class	Delete.Where
class	Do
static class	Do.Update
class	Equal
class	Exists
class	Full
class	Func
class	Great
class	GreateOrEqual
class	Group
static class	Group.By
class	Having
class	In
class	Inner
class	Insert
class	Into
class	IsNotNull
class	IsNull
class	JDBCParameter<T>
class	Left
class	Less
class	LessOrEqual
class	Like
class	Limit
class	Literal
static class	Literal.Alias
class	Name
class	Not
class	NotEqual
class	Nothing
class	Offset
class	On
class	Or
class	Order
static class	Order.By
class	Predicate
class	Query
class	Quot
class	Returning
class	Right
class	Select
static class	Select.From
class	Statement
class	Sum	TODO
class	Text
static class	ThenSelect.Select
class	Union
static class	Union.All
class	Update
static class	Update.Equation
static class	Update.Set
class	Using
static class	Using.Where
class	Values
class	Where
class	With
static class	With.As
static class	With.CommonTableExpression
static class	With.CommonTableQuery
static class	With.Delete
static class	With.Insert
static class	With.Recursive
static class	With.Update

参数类型为Directive的jaskell.sql中的方法

修饰符和类型	方法	说明
static Case	SQL._case(Directive expr)
Case.Else	Case.Then._else(Directive expr)
static And	SQL.and(Directive left, Directive right)
Coalesce	Coalesce.arg(Directive a)
Func	Func.arg(Directive a)
Coalesce	Coalesce.args(Directive... as)
Func	Func.args(Directive... as)
static Func	Func.avg(Directive argument)
By	By.by(Directive... names)
Group.By	Group.by(Directive... names)
Order.By	Order.by(Directive... names)
Coalesce	Coalesce.coalesce(Directive... directives)
static Coalesce	SQL.coalesce(Directive... names)
Predicate	Predicate.eq(Directive predicate)
static Equal	SQL.eq(Directive left, Directive right)
Exists	Not.exists(Directive directive)
Into	Into.fields(String table, Directive... fields)
From	CouldFrom.from(Directive f)
Delete.From	Delete.from(Directive name)
Select.From	Select.from(Directive f)
Select.From	ThenSelect.Select.from(Directive f)
static Func	SQL.func(String name, Directive arg)
static Func	SQL.func(String name, Directive... args)
static GreateOrEqual	SQL.ge(Directive left, Directive right)
Predicate	Predicate.gt(Directive predicate)
static Great	SQL.gt(Directive left, Directive right)
Predicate	Predicate.gte(Directive predicate)
Into	Insert.into(String name, Directive... fields)
jaskell.sql.Join	Alias.join(Directive other)
jaskell.sql.Join	CouldJoin.join(Directive other)
jaskell.sql.Join	Cross.join(Directive other)
jaskell.sql.Join	Full.join(Directive other)
jaskell.sql.Join	Inner.join(Directive other)
jaskell.sql.Join	Left.join(Directive other)
jaskell.sql.Join	Literal.Alias.join(Directive other)
jaskell.sql.Join	Literal.join(Directive other)
jaskell.sql.Join	Right.join(Directive other)
jaskell.sql.Join	Select.From.join(Directive other)
static LessOrEqual	SQL.le(Directive left, Directive right)
Predicate	Predicate.like(Directive predicate)
static Like	SQL.like(Directive left, Directive right)
default Limit	CouldLimit.limit(Directive l)
Limit	Query.limit(Directive l)
Predicate	Predicate.ls(Directive predicate)
static Less	SQL.lt(Directive left, Directive right)
Predicate	Predicate.lte(Directive predicate)
static Func	Func.max(Directive argument)
static Func	Func.min(Directive argument)
Predicate	Predicate.ne(Directive predicate)
static NotEqual	SQL.ne(Directive left, Directive right)
static Not	SQL.not(Directive directive)
default Offset	CouldOffset.offset(Directive o)
Offset	Limit.offset(Directive o)
Offset	Query.offset(Directive o)
static Or	SQL.or(Directive left, Directive right)
default Returning	CouldReturning.returning(Directive... fields)
Returning	Delete.Where.returning(Directive... names)
Returning	Returning.returning(Directive... fields)
Returning	Statement.returning(Directive names)
Select	Select.select(Directive... directives)
static Select	SQL.select(Directive... names)
default ThenSelect.Select	ThenSelect.select(Directive... names)
ThenSelect.Select	With.As.select(Directive... names)
Update.Set	Do.Update.set(Directive field, Directive value)
Update.Set	Do.Update.set(String field, Directive value)
Update.Set	Update.set(Directive field, Directive value)
Update.Set	Update.set(String field, Directive value)
Update.Set	Update.Set.set(Directive field, Directive value)
Update.Set	Update.Set.set(String field, Directive value)
Case.Then	Case.When.then(Directive expr)
Using	Delete.From.using(Directive... names)
Using	Update.Set.using(Directive... names)
Values	Into.values(Directive... directives)

类型变量类型为Directive的jaskell.sql中的方法参数

修饰符和类型	方法	说明
Group.By	Group.by(List<Directive> names)
Order.By	Order.by(List<Directive> names)
Predicate	Predicate.in(List<Directive> data)
Select	Select.select(List<Directive> names)
static Select	SQL.select(List<Directive> names)

参数类型为Directive的jaskell.sql中的构造器

构造器	说明
By(Directive... names)
By(Directive... names)
From(Directive name)
Func(String name, Directive... parameters)
Returning(Directive... fields)
Set(Directive field, Directive value)
Values(Directive... fields)
Where(Directive prefix, Predicate predicate)

类型变量类型为Directive的jaskell.sql中的构造器参数

构造器	说明
By(List<Directive> names)