// bindSinceID binds and validates parameter SinceID from query.
512124
func (o *ListTasksParams) bindSinceID(rawData []string, hasKey bool, formats strfmt.Registry) error {
	var raw string
	if len(rawData) > 0 {
		raw = rawData[len(rawData)-1]
	}

	// Required: false
	// AllowEmptyValue: false
	if raw == "" { // empty values pass all other validations
		return nil
	}

	value, err := swag.ConvertInt64(raw)
	if err != nil {
		return errors.InvalidType("sinceId", "query", "int64", raw)
	}
	o.SinceID = &value

	return nil
}
736430
func (actor Actor) BindServiceByApplicationAndServiceInstance(appGUID string, serviceInstanceGUID string) (Warnings, error) {
	_, warnings, err := actor.CloudControllerClient.CreateServiceBinding(appGUID, serviceInstanceGUID, "", false, nil)

	return Warnings(warnings), err
}
870242
func Convert_v1_BoundObjectReference_To_authentication_BoundObjectReference(in *v1.BoundObjectReference, out *authentication.BoundObjectReference, s conversion.Scope) error {
	return autoConvert_v1_BoundObjectReference_To_authentication_BoundObjectReference(in, out, s)
}
759741
func IN(binding ...interface{}) (exp Expression) {
	bindingRefs := strings.Repeat(",?", len(binding))
	return &PrefixedExp{" IN(", nil, bindingRefs[1:] + ")", binding}
}
9476
func NewBindTransceiver() Body {
	b := newBind(&Header{ID: BindTransceiverID})
	b.init()
	return b
}
752289
func (tx *Tx) Rebind(query string) string {
	return Rebind(BindType(tx.driverName), query)
}
645414
func (s *ServiceBroker) Bind(instanceID, bindingID string, details brokerapi.BindDetails) (brokerapi.Binding, error) {
	serviceBinding := NewServiceBinding()
	serviceBinding.SetInstanceID(instanceID)
	serviceBinding.SetBindingID(bindingID)
	serviceBinding.SetBindDetails(details)
	serviceBinding.SetActive(true)
	err := s.save(serviceBinding)
	return brokerapi.Binding{}, err
}
206998
func BindType(driverName string) int {
	switch driverName {
	case "postgres", "pgx", "pq-timeouts", "cloudsqlpostgres", "ql":
		return DOLLAR
	case "mysql":
		return QUESTION
	case "sqlite3":
		return QUESTION
	case "oci8", "ora", "goracle":
		return NAMED
	case "sqlserver":
		return AT
	}
	return UNKNOWN
}
149140
func (s *DefaultSubscriber) QueueBind(name, key string) error {
	err := s.channel.QueueBind(name, key, s.exchange, false, nil)
	if err != nil {
		return fmt.Errorf("Failed to bind queue %s with key %s on exchange '%s' (%s)", name, key, s.exchange, err)
	}
	return nil
}
838074
func (r User_Customer_OpenIdConnect) RemoveExternalBinding(externalBinding *datatypes.User_External_Binding) (resp bool, err error) {
	params := []interface{}{
		externalBinding,
	}
	err = r.Session.DoRequest("SoftLayer_User_Customer_OpenIdConnect", "removeExternalBinding", params, &r.Options, &resp)
	return
}
1020402
func (i *CharmInfo) EntityId() EntityId {
	return EntityId{
		Kind:      "charm",
		ModelUUID: i.ModelUUID,
		Id:        i.CharmURL,
	}
}
522252
func buildEntityIds(values [][]*querypb.Value, qSQL, entityColName string, qBindVars map[string]*querypb.BindVariable) ([]string, []map[string]*querypb.BindVariable) {
	sqls := make([]string, len(values))
	bindVars := make([]map[string]*querypb.BindVariable, len(values))
	for i, val := range values {
		var b bytes.Buffer
		b.Write([]byte(entityColName))
		bindVariables := make(map[string]*querypb.BindVariable)
		for k, v := range qBindVars {
			bindVariables[k] = v
		}
		bvName := fmt.Sprintf("%v_entity_ids", entityColName)
		bindVariables[bvName] = &querypb.BindVariable{
			Type:   querypb.Type_TUPLE,
			Values: val,
		}
		b.Write(inOperator)
		b.Write(sqlListIdentifier)
		b.Write([]byte(bvName))
		sqls[i] = insertSQLClause(qSQL, b.String())
		bindVars[i] = bindVariables
	}
	return sqls, bindVars
}
510836
func ReBind(query string, dialect Dialect) string {

	binder := dialect.BindVar(0)
	if binder == "?" {
		return query
	}

	for i, j := 0, strings.Index(query, "?"); j >= 0; i++ {
		query = strings.Replace(query, "?", dialect.BindVar(i), 1)
		j = strings.Index(query, "?")
	}
	return query
}
701447
func (p *parser) parseBind(binds *ast.LocalBinds) error {
	varID, err := p.popExpect(tokenIdentifier)
	if err != nil {
		return err
	}
	for _, b := range *binds {
		if b.Variable == ast.Identifier(varID.data) {
			return MakeStaticError(fmt.Sprintf("Duplicate local var: %v", varID.data), varID.loc)
		}
	}

	var fun *ast.Function
	if p.peek().kind == tokenParenL {
		p.pop()
		params, gotComma, err := p.parseParameters("function parameter")
		if err != nil {
			return err
		}
		fun = &ast.Function{
			Parameters:    *params,
			TrailingComma: gotComma,
		}
	}

	_, err = p.popExpectOp("=")
	if err != nil {
		return err
	}
	body, err := p.parse(maxPrecedence)
	if err != nil {
		return err
	}

	if fun != nil {
		fun.NodeBase = ast.NewNodeBaseLoc(locFromTokenAST(varID, body))
		fun.Body = body
		*binds = append(*binds, ast.LocalBind{
			Variable: ast.Identifier(varID.data),
			Body:     body,
			Fun:      fun,
		})
	} else {
		*binds = append(*binds, ast.LocalBind{
			Variable: ast.Identifier(varID.data),
			Body:     body,
		})
	}

	return nil
}
339321
func (o *GetTaskCommentsParams) validateSince(formats strfmt.Registry) error {

	if err := validate.FormatOf("since", "query", "date-time", o.Since.String(), formats); err != nil {
		return err
	}
	return nil
}
459656
func parseBind(flags *pflag.FlagSet, spec *api.ServiceSpec) error {
	if flags.Changed("bind") {
		binds, err := flags.GetStringSlice("bind")
		if err != nil {
			return err
		}

		container := spec.Task.GetContainer()

		for _, bind := range binds {
			parts := strings.SplitN(bind, ":", 2)
			if len(parts) != 2 {
				return fmt.Errorf("bind format %q not supported", bind)
			}
			container.Mounts = append(container.Mounts, api.Mount{
				Type:   api.MountTypeBind,
				Source: parts[0],
				Target: parts[1],
			})
		}
	}

	return nil
}
1048324
func (conn *FakeVTGateConn) ExecuteEntityIds(ctx context.Context, query string, keyspace string, entityColumnName string, entityKeyspaceIDs []*vtgatepb.ExecuteEntityIdsRequest_EntityId, bindVars map[string]*querypb.BindVariable, tabletType topodatapb.TabletType, session *vtgatepb.Session, options *querypb.ExecuteOptions) (*vtgatepb.Session, *sqltypes.Result, error) {
	panic("not implemented")
}