func addFilterToQuery(s *schema.Schema, q sq.SelectBuilder, filter map[string]interface{}, join bool) sq.SelectBuilder {
if filter == nil {
return q
}
for key, value := range filter {
property, err := s.GetPropertyByID(key)
var column string
if join {
column = makeColumn(s, *property)
} else {
column = quote(key)
}
if err != nil {
log.Notice(err.Error())
continue
}
if property.Type == "boolean" {
v := make([]bool, len(value.([]string)))
for i, j := range value.([]string) {
v[i], _ = strconv.ParseBool(j)
}
q = q.Where(sq.Eq{column: v})
} else {
q = q.Where(sq.Eq{column: value})
}
}
return q
}
func addFilterToQuery(s *schema.Schema, q sq.SelectBuilder, filter map[string]interface{}, join bool) (sq.SelectBuilder, error) {
if filter == nil {
return q, nil
}
for key, value := range filter {
property, err := s.GetPropertyByID(key)
if err != nil {
return q, err
}
var column string
if join {
column = makeColumn(s.GetDbTableName(), *property)
} else {
column = quote(key)
}
queryValues, ok := value.([]string)
if ok && property.Type == "boolean" {
v := make([]bool, len(queryValues))
for i, j := range queryValues {
v[i], _ = strconv.ParseBool(j)
}
q = q.Where(sq.Eq{column: v})
} else {
q = q.Where(sq.Eq{column: value})
}
}
return q, nil
}
// ApplyTo returns a new SelectBuilder after applying the paging effects of
// `p` to `sql`. This method provides the default case for paging: int64
// cursor-based paging by an id column.
func (p PageQuery) ApplyTo(
sql sq.SelectBuilder,
col string,
) (sq.SelectBuilder, error) {
sql = sql.Limit(p.Limit)
cursor, err := p.CursorInt64()
if err != nil {
return sql, err
}
switch p.Order {
case "asc":
sql = sql.
Where(fmt.Sprintf("%s > ?", col), cursor).
OrderBy(fmt.Sprintf("%s asc", col))
case "desc":
sql = sql.
Where(fmt.Sprintf("%s < ?", col), cursor).
OrderBy(fmt.Sprintf("%s desc", col))
default:
return sql, errors.Errorf("invalid order: %s", p.Order)
}
return sql, nil
}
func (f *EffectLedgerFilter) Apply(ctx context.Context, sql sq.SelectBuilder) (sq.SelectBuilder, error) {
start := TotalOrderID{LedgerSequence: f.LedgerSequence}
end := TotalOrderID{LedgerSequence: f.LedgerSequence + 1}
return sql.Where(
"(heff.history_operation_id >= ? AND heff.history_operation_id < ?)",
start.ToInt64(),
end.ToInt64(),
), nil
}
func (f *EffectAccountFilter) Apply(ctx context.Context, sql sq.SelectBuilder) (sq.SelectBuilder, error) {
var account HistoryAccountRecord
err := Get(ctx, HistoryAccountByAddressQuery{f.SqlQuery, f.AccountAddress}, &account)
if err != nil {
return sql, err
}
return sql.Where("heff.history_account_id = ?", account.Id), nil
}
func (f *EffectOperationFilter) Apply(ctx context.Context, sql sq.SelectBuilder) (sq.SelectBuilder, error) {
start := ParseTotalOrderID(f.OperationID)
end := start
end.IncOperationOrder()
return sql.Where(
"(heff.history_operation_id >= ? AND heff.history_operation_id < ?)",
start.ToInt64(),
end.ToInt64(),
), nil
}
func whereValueForKey(builder squirrel.SelectBuilder, src interface{}, key, value string) (squirrel.SelectBuilder, error) {
keyParts := strings.Split(key, "-")
sqlString := ""
switch len(keyParts) {
case 1:
if !structHasField(src, keyParts[0]) {
return builder, nil
}
sqlString = keyParts[0] + " = ?"
case 2:
op := Operator(keyParts[0])
field := keyParts[1]
if !structHasField(src, field) {
return builder, nil
}
switch op {
case Lt:
sqlString = field + " < ?"
case Lte:
sqlString = field + " <= ?"
case Gt:
sqlString = field + " > ?"
case Gte:
sqlString = field + " >= ?"
case In:
values := strings.Split(value, ",")
builder = builder.Where(squirrel.Eq{field: values})
return builder, nil
default:
return builder, nil
}
default:
return builder, nil
}
builder = builder.Where(sqlString, value)
return builder, nil
}
func (f *EffectTransactionFilter) Apply(ctx context.Context, sql sq.SelectBuilder) (sq.SelectBuilder, error) {
var tx TransactionRecord
err := Get(ctx, TransactionByHashQuery{f.SqlQuery, f.TransactionHash}, &tx)
if err != nil {
return sql, nil
}
start := ParseTotalOrderID(tx.Id)
end := start
end.TransactionOrder++
return sql.Where(
"(heff.history_operation_id >= ? AND heff.history_operation_id < ?)",
start.ToInt64(),
end.ToInt64(),
), nil
}
func (f *EffectTypeFilter) Apply(ctx context.Context, sql sq.SelectBuilder) (sq.SelectBuilder, error) {
return sql.Where("heff.type = ?", f.Type), nil
}