sqldialect

package
v0.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 31, 2025 License: Apache-2.0 Imports: 4 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AggregationColumnReferenceExpr 

type AggregationColumnReferenceExpr struct {
	// contains filtered or unexported fields
}

func AggregationColumnReference 

func AggregationColumnReference(expression Expr, alias string) *AggregationColumnReferenceExpr

func (*AggregationColumnReferenceExpr) ToSql 

func (e *AggregationColumnReferenceExpr) ToSql(dialect Dialect) (string, error)

type ArgExpr 

type ArgExpr struct {
	// contains filtered or unexported fields
}

func Arg 

func Arg(pos int) *ArgExpr

func (*ArgExpr) ToSql 

func (e *ArgExpr) ToSql(dialect Dialect) (string, error)

type AsExpr 

type AsExpr struct {
	// contains filtered or unexported fields
}

func As 

func As(expr Expr, alias TextExpr) *AsExpr

func (*AsExpr) ToSql 

func (e *AsExpr) ToSql(dialect Dialect) (string, error)

type BetweenExpr 

type BetweenExpr struct {
	// contains filtered or unexported fields
}

func Between 

func Between(col, from, to Expr) *BetweenExpr

func (*BetweenExpr) IsCondExpr 

func (e *BetweenExpr) IsCondExpr()

func (*BetweenExpr) ToSql 

func (e *BetweenExpr) ToSql(dialect Dialect) (string, error)

type BigQueryDialect 

type BigQueryDialect struct{}

func NewBigQueryDialect 

func NewBigQueryDialect() *BigQueryDialect

func (*BigQueryDialect) AddTime 

func (d *BigQueryDialect) AddTime(expr Expr, duration time.Duration) Expr

func (*BigQueryDialect) AggregationColumnReference 

func (d *BigQueryDialect) AggregationColumnReference(expression Expr, alias string) Expr

func (*BigQueryDialect) CeilTime 

func (d *BigQueryDialect) CeilTime(expr Expr, interval time.Duration) Expr

func (*BigQueryDialect) Coalesce 

func (d *BigQueryDialect) Coalesce(exprs ...Expr) Expr

func (*BigQueryDialect) Count 

func (d *BigQueryDialect) Count(expr Expr) Expr

func (*BigQueryDialect) CountIf 

func (d *BigQueryDialect) CountIf(expr Expr) Expr

func (*BigQueryDialect) Identifier 

func (d *BigQueryDialect) Identifier(identifier string) string

func (*BigQueryDialect) Median 

func (d *BigQueryDialect) Median(expr Expr) Expr

func (*BigQueryDialect) ResolveFqn 

func (d *BigQueryDialect) ResolveFqn(fqn *TableFqnExpr) (string, error)

func (*BigQueryDialect) ResolveTime 

func (d *BigQueryDialect) ResolveTime(t time.Time) (string, error)

func (*BigQueryDialect) ResolveTimeColumn 

func (d *BigQueryDialect) ResolveTimeColumn(expr *TimeColExpr) (string, error)

func (*BigQueryDialect) RoundTime 

func (d *BigQueryDialect) RoundTime(expr Expr, duration time.Duration) Expr

func (*BigQueryDialect) Stddev 

func (d *BigQueryDialect) Stddev(expr Expr) Expr

func (*BigQueryDialect) SubString added in v0.1.11 

func (d *BigQueryDialect) SubString(expr Expr, start int64, length int64) Expr

func (*BigQueryDialect) SubTime 

func (d *BigQueryDialect) SubTime(expr Expr, duration time.Duration) Expr

func (*BigQueryDialect) ToFloat64 

func (d *BigQueryDialect) ToFloat64(expr Expr) Expr

func (*BigQueryDialect) ToString 

func (d *BigQueryDialect) ToString(expr Expr) Expr

type ClickHouseDialect 

type ClickHouseDialect struct{}

func NewClickHouseDialect 

func NewClickHouseDialect() *ClickHouseDialect

func (*ClickHouseDialect) AddTime 

func (d *ClickHouseDialect) AddTime(expr Expr, duration time.Duration) Expr

func (*ClickHouseDialect) AggregationColumnReference 

func (d *ClickHouseDialect) AggregationColumnReference(expression Expr, alias string) Expr

func (*ClickHouseDialect) CeilTime 

func (d *ClickHouseDialect) CeilTime(expr Expr, interval time.Duration) Expr

func (*ClickHouseDialect) Coalesce 

func (d *ClickHouseDialect) Coalesce(exprs ...Expr) Expr

func (*ClickHouseDialect) Count 

func (d *ClickHouseDialect) Count(expr Expr) Expr

func (*ClickHouseDialect) CountIf 

func (d *ClickHouseDialect) CountIf(expr Expr) Expr

func (*ClickHouseDialect) Identifier 

func (d *ClickHouseDialect) Identifier(identifier string) string

func (*ClickHouseDialect) Median 

func (d *ClickHouseDialect) Median(expr Expr) Expr

func (*ClickHouseDialect) ResolveFqn 

func (d *ClickHouseDialect) ResolveFqn(fqn *TableFqnExpr) (string, error)

func (*ClickHouseDialect) ResolveTime 

func (d *ClickHouseDialect) ResolveTime(t time.Time) (string, error)

func (*ClickHouseDialect) ResolveTimeColumn 

func (d *ClickHouseDialect) ResolveTimeColumn(expr *TimeColExpr) (string, error)

func (*ClickHouseDialect) RoundTime 

func (d *ClickHouseDialect) RoundTime(expr Expr, duration time.Duration) Expr

func (*ClickHouseDialect) Stddev 

func (d *ClickHouseDialect) Stddev(expr Expr) Expr

func (*ClickHouseDialect) SubString added in v0.1.11 

func (d *ClickHouseDialect) SubString(expr Expr, start int64, length int64) Expr

func (*ClickHouseDialect) SubTime 

func (d *ClickHouseDialect) SubTime(expr Expr, duration time.Duration) Expr

func (*ClickHouseDialect) ToFloat64 

func (d *ClickHouseDialect) ToFloat64(expr Expr) Expr

func (*ClickHouseDialect) ToString 

func (d *ClickHouseDialect) ToString(expr Expr) Expr

type CoalesceExpr 

type CoalesceExpr struct {
	// contains filtered or unexported fields
}

func Coalesce 

func Coalesce(exprs ...Expr) *CoalesceExpr

func (*CoalesceExpr) ToSql 

func (e *CoalesceExpr) ToSql(dialect Dialect) (string, error)

type ColBaseExpr 

type ColBaseExpr struct {
	// contains filtered or unexported fields
}

func (*ColBaseExpr) ToSql 

func (s *ColBaseExpr) ToSql(dialect Dialect) (string, error)

type CompareExpr 

type CompareExpr struct {
	// contains filtered or unexported fields
}

func Eq 

func Eq(a, b Expr) *CompareExpr

func Gt 

func Gt(a, b Expr) *CompareExpr

func Gte 

func Gte(a, b Expr) *CompareExpr

func Lt 

func Lt(a, b Expr) *CompareExpr

func Lte 

func Lte(a, b Expr) *CompareExpr

func (*CompareExpr) IsCondExpr 

func (e *CompareExpr) IsCondExpr()

func (*CompareExpr) ToSql 

func (e *CompareExpr) ToSql(dialect Dialect) (string, error)

type CompareFn 

type CompareFn string
const (
	COMPARE_EQ  CompareFn = "="
	COMPARE_LT  CompareFn = "<"
	COMPARE_GT  CompareFn = ">"
	COMPARE_LTE CompareFn = "<="
	COMPARE_GTE CompareFn = ">="
)

type CondExpr 

type CondExpr interface {
	Expr
	IsCondExpr()
}

type CountAllExpr added in v0.1.8 

type CountAllExpr struct {
}

func CountAll added in v0.1.8 

func CountAll() *CountAllExpr

func (CountAllExpr) IsNumericExpr added in v0.1.8 

func (c CountAllExpr) IsNumericExpr()

func (CountAllExpr) ToSql added in v0.1.8 

func (c CountAllExpr) ToSql(dialect Dialect) (string, error)

type DatabricksDialect 

type DatabricksDialect struct{}

func NewDatabricksDialect 

func NewDatabricksDialect() *DatabricksDialect

func (*DatabricksDialect) AddTime 

func (d *DatabricksDialect) AddTime(expr Expr, duration time.Duration) Expr

func (*DatabricksDialect) AggregationColumnReference 

func (d *DatabricksDialect) AggregationColumnReference(expression Expr, alias string) Expr

func (*DatabricksDialect) CeilTime 

func (d *DatabricksDialect) CeilTime(expr Expr, interval time.Duration) Expr

func (*DatabricksDialect) Coalesce 

func (d *DatabricksDialect) Coalesce(exprs ...Expr) Expr

func (*DatabricksDialect) Count 

func (d *DatabricksDialect) Count(expr Expr) Expr

func (*DatabricksDialect) CountIf 

func (d *DatabricksDialect) CountIf(expr Expr) Expr

func (*DatabricksDialect) Identifier 

func (d *DatabricksDialect) Identifier(identifier string) string

func (*DatabricksDialect) Median 

func (d *DatabricksDialect) Median(expr Expr) Expr

func (*DatabricksDialect) ResolveFqn 

func (d *DatabricksDialect) ResolveFqn(fqn *TableFqnExpr) (string, error)

func (*DatabricksDialect) ResolveTime 

func (d *DatabricksDialect) ResolveTime(t time.Time) (string, error)

func (*DatabricksDialect) ResolveTimeColumn 

func (d *DatabricksDialect) ResolveTimeColumn(expr *TimeColExpr) (string, error)

func (*DatabricksDialect) RoundTime 

func (d *DatabricksDialect) RoundTime(expr Expr, duration time.Duration) Expr

func (*DatabricksDialect) Stddev 

func (d *DatabricksDialect) Stddev(expr Expr) Expr

func (*DatabricksDialect) SubString added in v0.1.11 

func (d *DatabricksDialect) SubString(expr Expr, start int64, length int64) Expr

func (*DatabricksDialect) SubTime 

func (d *DatabricksDialect) SubTime(expr Expr, duration time.Duration) Expr

func (*DatabricksDialect) ToFloat64 

func (d *DatabricksDialect) ToFloat64(expr Expr) Expr

func (*DatabricksDialect) ToString 

func (d *DatabricksDialect) ToString(expr Expr) Expr

type Dialect 

type Dialect interface {
	ResolveFqn(fqn *TableFqnExpr) (string, error)

	Count(expr Expr) Expr
	CountIf(Expr) Expr
	Median(Expr) Expr
	Stddev(Expr) Expr
	RoundTime(Expr, time.Duration) Expr
	CeilTime(Expr, time.Duration) Expr
	SubTime(Expr, time.Duration) Expr
	AddTime(Expr, time.Duration) Expr

	Identifier(string) string
	ToString(Expr) Expr
	Coalesce(exprs ...Expr) Expr
	ToFloat64(Expr) Expr
	SubString(expr Expr, start int64, length int64) Expr

	ResolveTime(time.Time) (string, error)
	ResolveTimeColumn(col *TimeColExpr) (string, error)
	AggregationColumnReference(expression Expr, alias string) Expr
}

type DistinctExpr 

type DistinctExpr struct {
	// contains filtered or unexported fields
}

func Distinct 

func Distinct(expr Expr) *DistinctExpr

func (*DistinctExpr) ToSql 

func (e *DistinctExpr) ToSql(dialect Dialect) (string, error)

type DuckDBDialect 

type DuckDBDialect struct{}

func NewDuckDBDialect 

func NewDuckDBDialect() *DuckDBDialect

func (*DuckDBDialect) AddTime 

func (d *DuckDBDialect) AddTime(expr Expr, duration time.Duration) Expr

func (*DuckDBDialect) AggregationColumnReference 

func (d *DuckDBDialect) AggregationColumnReference(expression Expr, alias string) Expr

func (*DuckDBDialect) CeilTime 

func (d *DuckDBDialect) CeilTime(expr Expr, interval time.Duration) Expr

func (*DuckDBDialect) Coalesce 

func (d *DuckDBDialect) Coalesce(exprs ...Expr) Expr

func (*DuckDBDialect) Count 

func (d *DuckDBDialect) Count(expr Expr) Expr

func (*DuckDBDialect) CountIf 

func (d *DuckDBDialect) CountIf(expr Expr) Expr

func (*DuckDBDialect) Identifier 

func (d *DuckDBDialect) Identifier(identifier string) string

func (*DuckDBDialect) Median 

func (d *DuckDBDialect) Median(expr Expr) Expr

func (*DuckDBDialect) ResolveFqn 

func (d *DuckDBDialect) ResolveFqn(fqn *TableFqnExpr) (string, error)

func (*DuckDBDialect) ResolveTime 

func (d *DuckDBDialect) ResolveTime(t time.Time) (string, error)

func (*DuckDBDialect) ResolveTimeColumn 

func (d *DuckDBDialect) ResolveTimeColumn(expr *TimeColExpr) (string, error)

func (*DuckDBDialect) RoundTime 

func (d *DuckDBDialect) RoundTime(expr Expr, interval time.Duration) Expr

func (*DuckDBDialect) Stddev 

func (d *DuckDBDialect) Stddev(expr Expr) Expr

func (*DuckDBDialect) SubString added in v0.1.11 

func (d *DuckDBDialect) SubString(expr Expr, start int64, length int64) Expr

func (*DuckDBDialect) SubTime 

func (d *DuckDBDialect) SubTime(expr Expr, duration time.Duration) Expr

func (*DuckDBDialect) ToFloat64 

func (d *DuckDBDialect) ToFloat64(expr Expr) Expr

func (*DuckDBDialect) ToString 

func (d *DuckDBDialect) ToString(expr Expr) Expr

type Expr 

type Expr interface {
	ToSql(dialect Dialect) (string, error)
}

type FnExpr 

type FnExpr struct {
	// contains filtered or unexported fields
}

func Fn 

func Fn(name string, ops ...Expr) *FnExpr

func (*FnExpr) ToSql 

func (e *FnExpr) ToSql(dialect Dialect) (string, error)

type IdentifierExpr 

type IdentifierExpr struct {
	// contains filtered or unexported fields
}

IdentifierExpr

func Identifier 

func Identifier(identifier string) *IdentifierExpr

func (*IdentifierExpr) IsTextExpr 

func (s *IdentifierExpr) IsTextExpr()

func (*IdentifierExpr) ToSql 

func (i *IdentifierExpr) ToSql(dialect Dialect) (string, error)

type InExpr 

type InExpr struct {
	// contains filtered or unexported fields
}

func In 

func In(col Expr, list ...Expr) *InExpr

func (*InExpr) IsCondExpr 

func (e *InExpr) IsCondExpr()

func (*InExpr) ToSql 

func (e *InExpr) ToSql(dialect Dialect) (string, error)

type IntLitExpr 

type IntLitExpr struct {
	// contains filtered or unexported fields
}

func Int64 

func Int64(val int64) *IntLitExpr

func (*IntLitExpr) IsNumericExpr 

func (e *IntLitExpr) IsNumericExpr()

func (*IntLitExpr) ToSql 

func (e *IntLitExpr) ToSql(dialect Dialect) (string, error)

type JoinDefExpr 

type JoinDefExpr interface {
	Expr
	IsJoinDefExpr()
}

type JoinExpr 

type JoinExpr struct {
	// contains filtered or unexported fields
}

func Join 

func Join(other TableExpr, how JoinDefExpr) *JoinExpr

func (*JoinExpr) IsJoinExpr 

func (t *JoinExpr) IsJoinExpr()

func (*JoinExpr) IsTableExpr added in v0.1.11 

func (t *JoinExpr) IsTableExpr()

func (*JoinExpr) ToSql 

func (t *JoinExpr) ToSql(dialect Dialect) (string, error)

type JoinOnExpr 

type JoinOnExpr struct {
	// contains filtered or unexported fields
}

func On 

func On(conds ...CondExpr) *JoinOnExpr

func (*JoinOnExpr) IsJoinDefExpr 

func (t *JoinOnExpr) IsJoinDefExpr()

func (*JoinOnExpr) ToSql 

func (t *JoinOnExpr) ToSql(dialect Dialect) (string, error)

type JoinUsingExpr 

type JoinUsingExpr struct {
	// contains filtered or unexported fields
}

func Using 

func Using(exprs ...Expr) *JoinUsingExpr

func (*JoinUsingExpr) IsJoinDefExpr 

func (t *JoinUsingExpr) IsJoinDefExpr()

func (*JoinUsingExpr) ToSql 

func (t *JoinUsingExpr) ToSql(dialect Dialect) (string, error)

type LimitExpr 

type LimitExpr struct {
	// contains filtered or unexported fields
}

func Limit 

func Limit(rows *IntLitExpr) *LimitExpr

func (*LimitExpr) ToSql 

func (e *LimitExpr) ToSql(dialect Dialect) (string, error)

type MySQLDialect 

type MySQLDialect struct{}

func NewMySQLDialect 

func NewMySQLDialect() *MySQLDialect

func (*MySQLDialect) AddTime 

func (d *MySQLDialect) AddTime(expr Expr, duration time.Duration) Expr

func (*MySQLDialect) AggregationColumnReference 

func (d *MySQLDialect) AggregationColumnReference(expression Expr, alias string) Expr

func (*MySQLDialect) CeilTime 

func (d *MySQLDialect) CeilTime(expr Expr, interval time.Duration) Expr

func (*MySQLDialect) Coalesce 

func (d *MySQLDialect) Coalesce(exprs ...Expr) Expr

func (*MySQLDialect) Count 

func (d *MySQLDialect) Count(expr Expr) Expr

func (*MySQLDialect) CountIf 

func (d *MySQLDialect) CountIf(expr Expr) Expr

func (*MySQLDialect) Identifier 

func (d *MySQLDialect) Identifier(identifier string) string

func (*MySQLDialect) Median 

func (d *MySQLDialect) Median(expr Expr) Expr

func (*MySQLDialect) ResolveFqn 

func (d *MySQLDialect) ResolveFqn(fqn *TableFqnExpr) (string, error)

func (*MySQLDialect) ResolveTime 

func (d *MySQLDialect) ResolveTime(t time.Time) (string, error)

func (*MySQLDialect) ResolveTimeColumn 

func (d *MySQLDialect) ResolveTimeColumn(expr *TimeColExpr) (string, error)

func (*MySQLDialect) RoundTime 

func (d *MySQLDialect) RoundTime(expr Expr, interval time.Duration) Expr

func (*MySQLDialect) Stddev 

func (d *MySQLDialect) Stddev(expr Expr) Expr

func (*MySQLDialect) SubString added in v0.1.11 

func (d *MySQLDialect) SubString(expr Expr, start int64, length int64) Expr

func (*MySQLDialect) SubTime 

func (d *MySQLDialect) SubTime(expr Expr, duration time.Duration) Expr

func (*MySQLDialect) ToFloat64 

func (d *MySQLDialect) ToFloat64(expr Expr) Expr

func (*MySQLDialect) ToString 

func (d *MySQLDialect) ToString(expr Expr) Expr

type NotImplementedExpr 

type NotImplementedExpr struct {
	// contains filtered or unexported fields
}

func NotImplemented 

func NotImplemented() *NotImplementedExpr

func NotImplementedWithExplanation 

func NotImplementedWithExplanation(msg string) *NotImplementedExpr

func (*NotImplementedExpr) ToSql 

func (e *NotImplementedExpr) ToSql(dialect Dialect) (string, error)

type NotInExpr 

type NotInExpr struct {
	// contains filtered or unexported fields
}

func NotIn 

func NotIn(col Expr, list ...Expr) *NotInExpr

func (*NotInExpr) IsCondExpr 

func (e *NotInExpr) IsCondExpr()

func (*NotInExpr) ToSql 

func (e *NotInExpr) ToSql(dialect Dialect) (string, error)

type NumericColExpr 

type NumericColExpr struct {
	ColBaseExpr
}

func NumericCol 

func NumericCol(name string) *NumericColExpr

func (*NumericColExpr) IsNumericExpr 

func (s *NumericColExpr) IsNumericExpr()

type NumericExpr 

type NumericExpr interface {
	Expr
	IsNumericExpr()
}

type OrderExpr 

type OrderExpr struct {
	// contains filtered or unexported fields
}

func Asc 

func Asc(expr Expr) *OrderExpr

func Desc 

func Desc(expr Expr) *OrderExpr

func (*OrderExpr) ToSql 

func (e *OrderExpr) ToSql(dialect Dialect) (string, error)

type PostgresDialect 

type PostgresDialect struct{}

func NewPostgresDialect 

func NewPostgresDialect() *PostgresDialect

func (*PostgresDialect) AddTime 

func (d *PostgresDialect) AddTime(expr Expr, duration time.Duration) Expr

func (*PostgresDialect) AggregationColumnReference 

func (d *PostgresDialect) AggregationColumnReference(expression Expr, alias string) Expr

func (*PostgresDialect) CeilTime 

func (d *PostgresDialect) CeilTime(expr Expr, interval time.Duration) Expr

func (*PostgresDialect) Coalesce 

func (d *PostgresDialect) Coalesce(exprs ...Expr) Expr

func (*PostgresDialect) Count 

func (d *PostgresDialect) Count(expr Expr) Expr

func (*PostgresDialect) CountIf 

func (d *PostgresDialect) CountIf(expr Expr) Expr

func (*PostgresDialect) Identifier 

func (d *PostgresDialect) Identifier(identifier string) string

func (*PostgresDialect) Median 

func (d *PostgresDialect) Median(expr Expr) Expr

func (*PostgresDialect) ResolveFqn 

func (d *PostgresDialect) ResolveFqn(fqn *TableFqnExpr) (string, error)

func (*PostgresDialect) ResolveTime 

func (d *PostgresDialect) ResolveTime(t time.Time) (string, error)

func (*PostgresDialect) ResolveTimeColumn 

func (d *PostgresDialect) ResolveTimeColumn(expr *TimeColExpr) (string, error)

func (*PostgresDialect) RoundTime 

func (d *PostgresDialect) RoundTime(expr Expr, interval time.Duration) Expr

func (*PostgresDialect) Stddev 

func (d *PostgresDialect) Stddev(expr Expr) Expr

func (*PostgresDialect) SubString added in v0.1.11 

func (d *PostgresDialect) SubString(expr Expr, start int64, length int64) Expr

func (*PostgresDialect) SubTime 

func (d *PostgresDialect) SubTime(expr Expr, duration time.Duration) Expr

func (*PostgresDialect) ToFloat64 

func (d *PostgresDialect) ToFloat64(expr Expr) Expr

func (*PostgresDialect) ToString 

func (d *PostgresDialect) ToString(expr Expr) Expr

type RedshiftDialect 

type RedshiftDialect struct{}

func NewRedshiftDialect 

func NewRedshiftDialect() *RedshiftDialect

func (*RedshiftDialect) AddTime 

func (d *RedshiftDialect) AddTime(expr Expr, duration time.Duration) Expr

func (*RedshiftDialect) AggregationColumnReference 

func (d *RedshiftDialect) AggregationColumnReference(expression Expr, alias string) Expr

func (*RedshiftDialect) CeilTime 

func (d *RedshiftDialect) CeilTime(expr Expr, interval time.Duration) Expr

func (*RedshiftDialect) Coalesce 

func (d *RedshiftDialect) Coalesce(exprs ...Expr) Expr

func (*RedshiftDialect) Count 

func (d *RedshiftDialect) Count(expr Expr) Expr

func (*RedshiftDialect) CountIf 

func (d *RedshiftDialect) CountIf(expr Expr) Expr

func (*RedshiftDialect) Identifier 

func (d *RedshiftDialect) Identifier(identifier string) string

func (*RedshiftDialect) Median 

func (d *RedshiftDialect) Median(expr Expr) Expr

func (*RedshiftDialect) ResolveFqn 

func (d *RedshiftDialect) ResolveFqn(fqn *TableFqnExpr) (string, error)

func (*RedshiftDialect) ResolveTime 

func (d *RedshiftDialect) ResolveTime(t time.Time) (string, error)

func (*RedshiftDialect) ResolveTimeColumn 

func (d *RedshiftDialect) ResolveTimeColumn(expr *TimeColExpr) (string, error)

func (*RedshiftDialect) RoundTime 

func (d *RedshiftDialect) RoundTime(expr Expr, interval time.Duration) Expr

func (*RedshiftDialect) Stddev 

func (d *RedshiftDialect) Stddev(expr Expr) Expr

func (*RedshiftDialect) SubString added in v0.1.11 

func (d *RedshiftDialect) SubString(expr Expr, start int64, length int64) Expr

func (*RedshiftDialect) SubTime 

func (d *RedshiftDialect) SubTime(expr Expr, duration time.Duration) Expr

func (*RedshiftDialect) ToFloat64 

func (d *RedshiftDialect) ToFloat64(expr Expr) Expr

func (*RedshiftDialect) ToString 

func (d *RedshiftDialect) ToString(expr Expr) Expr

type Select 

type Select struct {
	// contains filtered or unexported fields
}

func NewSelect 

func NewSelect() *Select

func (*Select) Cols 

func (s *Select) Cols(cols ...Expr) *Select

func (*Select) From 

func (s *Select) From(table TableExpr) *Select

func (*Select) GroupBy 

func (s *Select) GroupBy(groupBy ...Expr) *Select

func (*Select) Join 

func (s *Select) Join(other TableExpr, how JoinDefExpr) *Select

func (*Select) OrderBy 

func (s *Select) OrderBy(orderBy ...*OrderExpr) *Select

func (*Select) ToSql 

func (s *Select) ToSql(dialect Dialect) (string, error)

func (*Select) Where 

func (s *Select) Where(conds ...CondExpr) *Select

func (*Select) WithLimit 

func (s *Select) WithLimit(limit *LimitExpr) *Select

type SnowflakeDialect 

type SnowflakeDialect struct{}

func NewSnowflakeDialect 

func NewSnowflakeDialect() *SnowflakeDialect

func (*SnowflakeDialect) AddTime 

func (d *SnowflakeDialect) AddTime(expr Expr, duration time.Duration) Expr

func (*SnowflakeDialect) AggregationColumnReference 

func (d *SnowflakeDialect) AggregationColumnReference(expression Expr, alias string) Expr

func (*SnowflakeDialect) CeilTime 

func (d *SnowflakeDialect) CeilTime(expr Expr, interval time.Duration) Expr

func (*SnowflakeDialect) Coalesce 

func (d *SnowflakeDialect) Coalesce(exprs ...Expr) Expr

func (*SnowflakeDialect) Count 

func (d *SnowflakeDialect) Count(expr Expr) Expr

func (*SnowflakeDialect) CountIf 

func (d *SnowflakeDialect) CountIf(expr Expr) Expr

func (*SnowflakeDialect) Identifier 

func (d *SnowflakeDialect) Identifier(identifier string) string

func (*SnowflakeDialect) Median 

func (d *SnowflakeDialect) Median(expr Expr) Expr

func (*SnowflakeDialect) ResolveFqn 

func (d *SnowflakeDialect) ResolveFqn(fqn *TableFqnExpr) (string, error)

func (*SnowflakeDialect) ResolveTime 

func (d *SnowflakeDialect) ResolveTime(t time.Time) (string, error)

func (*SnowflakeDialect) ResolveTimeColumn 

func (d *SnowflakeDialect) ResolveTimeColumn(expr *TimeColExpr) (string, error)

func (*SnowflakeDialect) RoundTime 

func (d *SnowflakeDialect) RoundTime(expr Expr, duration time.Duration) Expr

func (*SnowflakeDialect) Stddev 

func (d *SnowflakeDialect) Stddev(expr Expr) Expr

func (*SnowflakeDialect) SubString added in v0.1.11 

func (d *SnowflakeDialect) SubString(expr Expr, start int64, length int64) Expr

func (*SnowflakeDialect) SubTime 

func (d *SnowflakeDialect) SubTime(expr Expr, duration time.Duration) Expr

func (*SnowflakeDialect) ToFloat64 

func (d *SnowflakeDialect) ToFloat64(expr Expr) Expr

func (*SnowflakeDialect) ToString 

func (d *SnowflakeDialect) ToString(expr Expr) Expr

type SqlExpr 

type SqlExpr struct {
	// contains filtered or unexported fields
}

func Sql 

func Sql(sql string) *SqlExpr

func (*SqlExpr) IsCondExpr 

func (s *SqlExpr) IsCondExpr()

func (*SqlExpr) IsJoinExpr 

func (s *SqlExpr) IsJoinExpr()

func (*SqlExpr) IsNumericExpr 

func (s *SqlExpr) IsNumericExpr()

func (*SqlExpr) IsTableExpr 

func (s *SqlExpr) IsTableExpr()

func (*SqlExpr) IsTextExpr 

func (s *SqlExpr) IsTextExpr()

func (*SqlExpr) IsTimeExpr 

func (s *SqlExpr) IsTimeExpr()

func (*SqlExpr) ToSql 

func (s *SqlExpr) ToSql(dialect Dialect) (string, error)

type StarExpr 

type StarExpr struct {
	// contains filtered or unexported fields
}

func Star 

func Star(except ...Expr) *StarExpr

func (*StarExpr) ToSql 

func (s *StarExpr) ToSql(dialect Dialect) (string, error)

type StringLitExpr 

type StringLitExpr struct {
	// contains filtered or unexported fields
}

func String 

func String(val string) *StringLitExpr

func Stringf 

func Stringf(format string, val ...any) *StringLitExpr

func (*StringLitExpr) IsTextExpr added in v0.1.11 

func (e *StringLitExpr) IsTextExpr()

func (*StringLitExpr) ToSql 

func (e *StringLitExpr) ToSql(dialect Dialect) (string, error)

type SubStringExpr added in v0.1.11 

type SubStringExpr struct {
	// contains filtered or unexported fields
}

func SubString added in v0.1.11 

func SubString(expr Expr, start int64, length int64) *SubStringExpr

func (SubStringExpr) ToSql added in v0.1.11 

func (s SubStringExpr) ToSql(dialect Dialect) (string, error)

type TableExpr 

type TableExpr interface {
	Expr
	IsTableExpr()
}

type TableFqnExpr 

type TableFqnExpr struct {
	// contains filtered or unexported fields
}

func TableFqn 

func TableFqn(projectId, datasetId, tableId string) *TableFqnExpr

func (*TableFqnExpr) IsTableExpr 

func (t *TableFqnExpr) IsTableExpr()

func (*TableFqnExpr) ToSql 

func (t *TableFqnExpr) ToSql(dialect Dialect) (string, error)

type TextColExpr 

type TextColExpr struct {
	ColBaseExpr
}

func TextCol 

func TextCol(name string) *TextColExpr

func (*TextColExpr) IsTextExpr 

func (s *TextColExpr) IsTextExpr()

type TextExpr 

type TextExpr interface {
	Expr
	IsTextExpr()
}

type TimeColExpr 

type TimeColExpr struct {
	// contains filtered or unexported fields
}

func TimeCol 

func TimeCol(name string) *TimeColExpr

func (*TimeColExpr) IsTimeExpr 

func (t *TimeColExpr) IsTimeExpr()

func (*TimeColExpr) ToSql 

func (t *TimeColExpr) ToSql(dialect Dialect) (string, error)

type TimeExpr 

type TimeExpr interface {
	Expr
	IsTimeExpr()
}

type TimeLitExpr 

type TimeLitExpr struct {
	// contains filtered or unexported fields
}

func Time 

func Time(val time.Time) *TimeLitExpr

func (*TimeLitExpr) IsTimeExpr 

func (e *TimeLitExpr) IsTimeExpr()

func (*TimeLitExpr) ToSql 

func (e *TimeLitExpr) ToSql(dialect Dialect) (string, error)

type TimeUnit 

type TimeUnit string
const TimeUnitDay TimeUnit = "DAY"
const TimeUnitHour TimeUnit = "HOUR"
const TimeUnitMinute TimeUnit = "MINUTE"
const TimeUnitSecond TimeUnit = "SECOND"

type ToCondExpr added in v0.1.8 

type ToCondExpr interface {
	ToCondExpr() CondExpr
}

type ToFloat64Expr 

type ToFloat64Expr struct {
	// contains filtered or unexported fields
}

func ToFloat64 

func ToFloat64(expr Expr) *ToFloat64Expr

func (*ToFloat64Expr) IsNumericExpr added in v0.1.11 

func (e *ToFloat64Expr) IsNumericExpr()

func (*ToFloat64Expr) ToSql 

func (e *ToFloat64Expr) ToSql(dialect Dialect) (string, error)

type ToStringExpr 

type ToStringExpr struct {
	// contains filtered or unexported fields
}

func ToString 

func ToString(expr Expr) *ToStringExpr

func (*ToStringExpr) ToSql 

func (e *ToStringExpr) ToSql(dialect Dialect) (string, error)

type WrapSqlExpr 

type WrapSqlExpr struct {
	// contains filtered or unexported fields
}

func WrapSql 

func WrapSql(sql string, wrapped ...Expr) *WrapSqlExpr

func (*WrapSqlExpr) ToSql 

func (e *WrapSqlExpr) ToSql(dialect Dialect) (string, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.