// generateFieldQuery generates a query with an impossible where. // This will be used on the RHS node to fetch field info if the LHS // returns no result. func (rb *route) generateFieldQuery(sel *sqlparser.Select, jt *jointab) string { formatter := func(buf *sqlparser.TrackedBuffer, node sqlparser.SQLNode) { switch node := node.(type) { case *sqlparser.Select: buf.Myprintf("select %v from %v where 1 != 1", node.SelectExprs, node.From) return case *sqlparser.JoinTableExpr: if node.Join == sqlparser.LeftJoinStr || node.Join == sqlparser.RightJoinStr { // ON clause is requried buf.Myprintf("%v %s %v on 1 != 1", node.LeftExpr, node.Join, node.RightExpr) } else { buf.Myprintf("%v %s %v", node.LeftExpr, node.Join, node.RightExpr) } return case *sqlparser.ColName: if !rb.isLocal(node) { _, joinVar := jt.Lookup(node) buf.Myprintf("%a", ":"+joinVar) return } case *sqlparser.TableName: node.Name.Format(buf) return } node.Format(buf) } buf := sqlparser.NewTrackedBuffer(formatter) formatter(buf, sel) return buf.ParsedQuery().Query }
// GenerateSelectOuterQuery generates the outer query for dmls. func GenerateSelectOuterQuery(sel *sqlparser.Select, tableInfo *schema.Table) *sqlparser.ParsedQuery { buf := sqlparser.NewTrackedBuffer(nil) fmt.Fprintf(buf, "select ") writeColumnList(buf, tableInfo.Columns) buf.Myprintf(" from %v where %a", sel.From, ":#pk") return buf.ParsedQuery() }
// GenerateFieldQuery generates a query to just fetch the field info // by adding impossible where clauses as needed. func GenerateFieldQuery(statement sqlparser.Statement) *sqlparser.ParsedQuery { buf := sqlparser.NewTrackedBuffer(FormatImpossible) buf.Myprintf("%v", statement) if buf.HasBindVars() { return nil } return buf.ParsedQuery() }
func GenerateEqualOuterQuery(sel *sqlparser.Select, tableInfo *schema.Table) *sqlparser.ParsedQuery { buf := sqlparser.NewTrackedBuffer(nil) fmt.Fprintf(buf, "select ") writeColumnList(buf, tableInfo.Columns) buf.Myprintf(" from %v where ", sel.From) generatePKWhere(buf, tableInfo.Indexes[0]) return buf.ParsedQuery() }
func GenerateInOuterQuery(sel *sqlparser.Select, tableInfo *schema.Table) *sqlparser.ParsedQuery { buf := sqlparser.NewTrackedBuffer(nil) fmt.Fprintf(buf, "select ") writeColumnList(buf, tableInfo.Columns) // We assume there is one and only one PK column. // A '*' argument name means all variables of the list. buf.Myprintf(" from %v where %s in (%a)", sel.From, tableInfo.Indexes[0].Columns[0], "*") return buf.ParsedQuery() }
// GenerateInsertOuterQuery generates the outer query for inserts. func GenerateInsertOuterQuery(ins *sqlparser.Insert) *sqlparser.ParsedQuery { buf := sqlparser.NewTrackedBuffer(nil) buf.Myprintf("insert %v%sinto %v%v values %a", ins.Comments, ins.Ignore, ins.Table, ins.Columns, ":#values", ) return buf.ParsedQuery() }
// GenerateSelectLimitQuery generates a select query with a limit clause. func GenerateSelectLimitQuery(selStmt sqlparser.SelectStatement) *sqlparser.ParsedQuery { buf := sqlparser.NewTrackedBuffer(nil) sel, ok := selStmt.(*sqlparser.Select) if ok { limit := sel.Limit if limit == nil { sel.Limit = execLimit defer func() { sel.Limit = nil }() } } buf.Myprintf("%v", selStmt) return buf.ParsedQuery() }
// GenerateSubquery generates a subquery based on the input parameters. func GenerateSubquery(columns []string, table *sqlparser.AliasedTableExpr, where *sqlparser.Where, order sqlparser.OrderBy, limit *sqlparser.Limit, forUpdate bool) *sqlparser.ParsedQuery { buf := sqlparser.NewTrackedBuffer(nil) if limit == nil { limit = execLimit } fmt.Fprintf(buf, "select ") i := 0 for i = 0; i < len(columns)-1; i++ { fmt.Fprintf(buf, "%s, ", columns[i]) } fmt.Fprintf(buf, "%s", columns[i]) buf.Myprintf(" from %v%v%v%v", table, where, order, limit) if forUpdate { buf.Myprintf(sqlparser.ForUpdateStr) } return buf.ParsedQuery() }
func analyze(line []byte) { for _, ignore := range ignores { if bytes.HasPrefix(line, ignore) { return } } dml := string(bytes.TrimRight(line, "\n")) ast, err := sqlparser.Parse(dml) if err != nil { log.Errorf("Error parsing %s", dml) return } bindIndex = 0 buf := sqlparser.NewTrackedBuffer(FormatWithBind) buf.Myprintf("%v", ast) addQuery(buf.ParsedQuery().Query) }
// GenerateFullQuery generates the full query from the ast. func GenerateFullQuery(statement sqlparser.Statement) *sqlparser.ParsedQuery { buf := sqlparser.NewTrackedBuffer(nil) statement.Format(buf) return buf.ParsedQuery() }
func GenerateDeleteOuterQuery(del *sqlparser.Delete, pkIndex *schema.Index) *sqlparser.ParsedQuery { buf := sqlparser.NewTrackedBuffer(nil) buf.Myprintf("delete %vfrom %v where ", del.Comments, del.Table) generatePKWhere(buf, pkIndex) return buf.ParsedQuery() }
// Wireup performs the wire-up tasks. func (rb *route) Wireup(bldr builder, jt *jointab) error { // Resolve values stored in the builder. var err error switch vals := rb.ERoute.Values.(type) { case *sqlparser.ComparisonExpr: // A comparison expression is stored only if it was an IN clause. // We have to convert it to use a list argutment and resolve values. rb.ERoute.Values, err = rb.procureValues(bldr, jt, vals.Right) if err != nil { return err } vals.Right = sqlparser.ListArg("::" + engine.ListVarName) default: rb.ERoute.Values, err = rb.procureValues(bldr, jt, vals) if err != nil { return err } } // Fix up the AST. _ = sqlparser.Walk(func(node sqlparser.SQLNode) (bool, error) { switch node := node.(type) { case *sqlparser.Select: if len(node.SelectExprs) == 0 { node.SelectExprs = sqlparser.SelectExprs([]sqlparser.SelectExpr{ &sqlparser.NonStarExpr{ Expr: sqlparser.NumVal([]byte{'1'}), }, }) } case *sqlparser.ComparisonExpr: if node.Operator == sqlparser.EqualStr { if exprIsValue(node.Left, rb) && !exprIsValue(node.Right, rb) { node.Left, node.Right = node.Right, node.Left } } } return true, nil }, &rb.Select) // Generate query while simultaneously resolving values. varFormatter := func(buf *sqlparser.TrackedBuffer, node sqlparser.SQLNode) { switch node := node.(type) { case *sqlparser.ColName: if !rb.isLocal(node) { joinVar := jt.Procure(bldr, node, rb.Order()) rb.ERoute.JoinVars[joinVar] = struct{}{} buf.Myprintf("%a", ":"+joinVar) return } case *sqlparser.TableName: node.Name.Format(buf) return } node.Format(buf) } buf := sqlparser.NewTrackedBuffer(varFormatter) varFormatter(buf, &rb.Select) rb.ERoute.Query = buf.ParsedQuery().Query rb.ERoute.FieldQuery = rb.generateFieldQuery(&rb.Select, jt) return nil }
func Fuzz(data []byte) int { stmt, err := sqlparser.Parse(string(data)) if err != nil { if stmt != nil { panic("stmt is not nil on error") } return 0 } if true { data1 := sqlparser.String(stmt) stmt1, err := sqlparser.Parse(data1) if err != nil { fmt.Printf("data0: %q\n", data) fmt.Printf("data1: %q\n", data1) panic(err) } if !fuzz.DeepEqual(stmt, stmt1) { fmt.Printf("data0: %q\n", data) fmt.Printf("data1: %q\n", data1) panic("not equal") } } else { sqlparser.String(stmt) } if sel, ok := stmt.(*sqlparser.Select); ok { var nodes []sqlparser.SQLNode for _, x := range sel.From { nodes = append(nodes, x) } for _, x := range sel.From { nodes = append(nodes, x) } for _, x := range sel.SelectExprs { nodes = append(nodes, x) } for _, x := range sel.GroupBy { nodes = append(nodes, x) } for _, x := range sel.OrderBy { nodes = append(nodes, x) } nodes = append(nodes, sel.Where) nodes = append(nodes, sel.Having) nodes = append(nodes, sel.Limit) for _, n := range nodes { if n == nil { continue } if x, ok := n.(sqlparser.SimpleTableExpr); ok { sqlparser.GetTableName(x) } if x, ok := n.(sqlparser.Expr); ok { sqlparser.GetColName(x) } if x, ok := n.(sqlparser.ValExpr); ok { sqlparser.IsValue(x) } if x, ok := n.(sqlparser.ValExpr); ok { sqlparser.IsColName(x) } if x, ok := n.(sqlparser.ValExpr); ok { sqlparser.IsSimpleTuple(x) } if x, ok := n.(sqlparser.ValExpr); ok { sqlparser.AsInterface(x) } if x, ok := n.(sqlparser.BoolExpr); ok { sqlparser.HasINClause([]sqlparser.BoolExpr{x}) } } } buf := sqlparser.NewTrackedBuffer(nil) stmt.Format(buf) pq := buf.ParsedQuery() vars := map[string]interface{}{ "A": 42, "B": 123123123, "C": "", "D": "a", "E": "foobar", "F": 1.1, } pq.GenerateQuery(vars) return 1 }
func GenerateUpdateOuterQuery(upd *sqlparser.Update, pkIndex *schema.Index) *sqlparser.ParsedQuery { buf := sqlparser.NewTrackedBuffer(nil) buf.Myprintf("update %v%v set %v where ", upd.Comments, upd.Table, upd.Exprs) generatePKWhere(buf, pkIndex) return buf.ParsedQuery() }
// GenerateUpdateOuterQuery generates the outer query for updates. func GenerateUpdateOuterQuery(upd *sqlparser.Update) *sqlparser.ParsedQuery { buf := sqlparser.NewTrackedBuffer(nil) buf.Myprintf("update %v%v set %v where %a", upd.Comments, upd.Table, upd.Exprs, ":#pk") return buf.ParsedQuery() }
func generateQuery(statement sqlparser.Statement) string { buf := sqlparser.NewTrackedBuffer(dmlFormatter) statement.Format(buf) return buf.String() }
// GenerateDeleteOuterQuery generates the outer query for deletes. func GenerateDeleteOuterQuery(del *sqlparser.Delete) *sqlparser.ParsedQuery { buf := sqlparser.NewTrackedBuffer(nil) buf.Myprintf("delete %vfrom %v where %a", del.Comments, del.Table, ":#pk") return buf.ParsedQuery() }
func buildParsedQuery(in string, vars ...interface{}) *sqlparser.ParsedQuery { buf := sqlparser.NewTrackedBuffer(nil) buf.Myprintf(in, vars...) return buf.ParsedQuery() }