Add sqlite3 adapter

README.md

@@ -41,6 +41,7 @@ In order to start using goqu with your database you need to load an adapter. We
 
 1. Postgres - `import "github.com/doug-martin/goqu/adapters/postgres"`
 2. MySQL - `import "github.com/doug-martin/goqu/adapters/mysql"`
+3. SQLite3 - `import "github.com/doug-martin/goqu/adapters/sqlite3"`
 
 Adapters in goqu work the same way as a driver with the database in that they register themselves with goqu once loaded.
 
@@ -170,7 +171,7 @@ Please see the exmaples for [`I()`](https://godoc.org/github.com/doug-martin/goq
 ```go
 goqu.L(`"col"::TEXT = ""other_col"::text`)
 ```
-You can also use placeholders in your literal. When using the LiteralExpressions placeholders are normalized to the ? character and will be transformed to the correct placeholder for your adapter (e.g. `?` mysql, `$1` postgres)
+You can also use placeholders in your literal. When using the LiteralExpressions placeholders are normalized to the ? character and will be transformed to the correct placeholder for your adapter (e.g. `?` mysql, `$1` postgres, `?` sqlite3)
 ```go
 goqu.L("col IN (?, ?, ?)", "a", "b", "c")
 ```
@@ -590,7 +591,7 @@ func init() {
 }
 ```
 
-If you are looking to write your own adapter take a look at the postgres or mysql adapter located at https://github.com/doug-martin/goqu/tree/master/adapters.
+If you are looking to write your own adapter take a look at the postgres/mysql or sqlite3 adapter located at https://github.com/doug-martin/goqu/tree/master/adapters.
 
 ## Contributions
 

adapters/sqlite3/dataset_adapter_test.go

@@ -0,0 +1,182 @@
+package sqlite3
+
+import (
+	"github.com/doug-martin/goqu"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+	"regexp"
+	"testing"
+)
+
+type datasetAdapterTest struct {
+	suite.Suite
+}
+
+func (me *datasetAdapterTest) TestPlaceholderSql() {
+	t := me.T()
+	buf := goqu.NewSqlBuilder(true)
+	dsAdapter := newDatasetAdapter(goqu.From("test"))
+	dsAdapter.PlaceHolderSql(buf, 1)
+	dsAdapter.PlaceHolderSql(buf, 2)
+	dsAdapter.PlaceHolderSql(buf, 3)
+	dsAdapter.PlaceHolderSql(buf, 4)
+	sql, args := buf.ToSql()
+	assert.Equal(t, args, []interface{}{1, 2, 3, 4})
+	assert.Equal(t, sql, "????")
+}
+
+func (me *datasetAdapterTest) GetDs(table string) *goqu.Dataset {
+	ret := goqu.From(table)
+	adapter := newDatasetAdapter(ret)
+	ret.SetAdapter(adapter)
+	return ret
+}
+
+func (me *datasetAdapterTest) TestSupportsReturn() {
+	t := me.T()
+	dsAdapter := me.GetDs("test").Adapter()
+	assert.False(t, dsAdapter.SupportsReturn())
+}
+
+func (me *datasetAdapterTest) TestSupportsLimitOnDelete() {
+	t := me.T()
+	dsAdapter := me.GetDs("test").Adapter()
+	assert.True(t, dsAdapter.SupportsLimitOnDelete())
+}
+
+func (me *datasetAdapterTest) TestSupportsLimitOnUpdate() {
+	t := me.T()
+	dsAdapter := me.GetDs("test").Adapter()
+	assert.True(t, dsAdapter.SupportsLimitOnDelete())
+}
+
+func (me *datasetAdapterTest) TestSupportsOrderByOnDelete() {
+	t := me.T()
+	dsAdapter := me.GetDs("test").Adapter()
+	assert.True(t, dsAdapter.SupportsLimitOnDelete())
+}
+
+func (me *datasetAdapterTest) TestSupportsOrderByOnUpdate() {
+	t := me.T()
+	dsAdapter := me.GetDs("test").Adapter()
+	assert.True(t, dsAdapter.SupportsLimitOnDelete())
+}
+
+func (me *datasetAdapterTest) TestIdentifiers() {
+	t := me.T()
+	ds := me.GetDs("test")
+	sql, err := ds.Select("a", goqu.I("a.b.c"), goqu.I("c.d"), goqu.I("test").As("test")).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT `a`, `a`.`b`.`c`, `c`.`d`, `test` AS `test` FROM `test`")
+}
+
+func (me *datasetAdapterTest) TestLiteralString() {
+	t := me.T()
+	ds := me.GetDs("test")
+	sql, err := ds.Where(goqu.I("a").Eq("test")).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` = 'test')")
+
+	sql, err = ds.Where(goqu.I("a").Eq("test'test")).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` = 'test\\'test')")
+
+	sql, err = ds.Where(goqu.I("a").Eq(`test"test`)).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` = 'test\\\"test')")
+
+	sql, err = ds.Where(goqu.I("a").Eq(`test\test`)).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` = 'test\\\\test')")
+
+	sql, err = ds.Where(goqu.I("a").Eq("test\ntest")).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` = 'test\\ntest')")
+
+	sql, err = ds.Where(goqu.I("a").Eq("test\rtest")).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` = 'test\\rtest')")
+
+	sql, err = ds.Where(goqu.I("a").Eq("test\x00test")).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` = 'test\\x00test')")
+
+	sql, err = ds.Where(goqu.I("a").Eq("test\x1atest")).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` = 'test\\x1atest')")
+}
+
+func (me *datasetAdapterTest) TestBooleanOperations() {
+	t := me.T()
+	ds := me.GetDs("test")
+	sql, err := ds.Where(goqu.I("a").Eq(true)).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` IS TRUE)")
+	sql, err = ds.Where(goqu.I("a").Eq(false)).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` IS FALSE)")
+	sql, err = ds.Where(goqu.I("a").Is(true)).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` IS TRUE)")
+	sql, err = ds.Where(goqu.I("a").Is(false)).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` IS FALSE)")
+	sql, err = ds.Where(goqu.I("a").IsTrue()).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` IS TRUE)")
+	sql, err = ds.Where(goqu.I("a").IsFalse()).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` IS FALSE)")
+
+	sql, err = ds.Where(goqu.I("a").Neq(true)).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` IS NOT TRUE)")
+	sql, err = ds.Where(goqu.I("a").Neq(false)).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` IS NOT FALSE)")
+	sql, err = ds.Where(goqu.I("a").IsNot(true)).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` IS NOT TRUE)")
+	sql, err = ds.Where(goqu.I("a").IsNot(false)).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` IS NOT FALSE)")
+	sql, err = ds.Where(goqu.I("a").IsNotTrue()).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` IS NOT TRUE)")
+	sql, err = ds.Where(goqu.I("a").IsNotFalse()).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` IS NOT FALSE)")
+
+	sql, err = ds.Where(goqu.I("a").Like("a%")).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` LIKE BINARY 'a%')")
+
+	sql, err = ds.Where(goqu.I("a").NotLike("a%")).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` NOT LIKE BINARY 'a%')")
+
+	sql, err = ds.Where(goqu.I("a").ILike("a%")).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` LIKE 'a%')")
+	sql, err = ds.Where(goqu.I("a").NotILike("a%")).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` NOT LIKE 'a%')")
+
+	sql, err = ds.Where(goqu.I("a").Like(regexp.MustCompile("(a|b)"))).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` REGEXP BINARY '(a|b)')")
+	sql, err = ds.Where(goqu.I("a").NotLike(regexp.MustCompile("(a|b)"))).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` NOT REGEXP BINARY '(a|b)')")
+	sql, err = ds.Where(goqu.I("a").ILike(regexp.MustCompile("(a|b)"))).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` REGEXP '(a|b)')")
+	sql, err = ds.Where(goqu.I("a").NotILike(regexp.MustCompile("(a|b)"))).Sql()
+	assert.NoError(t, err)
+	assert.Equal(t, sql, "SELECT * FROM `test` WHERE (`a` NOT REGEXP '(a|b)')")
+
+}
+
+func TestDatasetAdapterSuite(t *testing.T) {
+	suite.Run(t, new(datasetAdapterTest))
+}

adapters/sqlite3/sqlite3.go

@@ -0,0 +1,104 @@
+package sqlite3
+
+import (
+	"github.com/doug-martin/goqu"
+)
+
+var (
+	placeholder_rune    = '?'
+	quote_rune          = '`'
+	singlq_quote        = '\''
+	default_values_frag = []byte("")
+	sqlite3_true        = []byte("1")
+	sqlite3_false       = []byte("0")
+	time_format         = "2006-01-02 15:04:05"
+	operator_lookup     = map[goqu.BooleanOperation][]byte{
+		goqu.EQ_OP:                []byte("="),
+		goqu.NEQ_OP:               []byte("!="),
+		goqu.GT_OP:                []byte(">"),
+		goqu.GTE_OP:               []byte(">="),
+		goqu.LT_OP:                []byte("<"),
+		goqu.LTE_OP:               []byte("<="),
+		goqu.IN_OP:                []byte("IN"),
+		goqu.NOT_IN_OP:            []byte("NOT IN"),
+		goqu.IS_OP:                []byte("IS"),
+		goqu.IS_NOT_OP:            []byte("IS NOT"),
+		goqu.LIKE_OP:              []byte("LIKE BINARY"),
+		goqu.NOT_LIKE_OP:          []byte("NOT LIKE BINARY"),
+		goqu.I_LIKE_OP:            []byte("LIKE"),
+		goqu.NOT_I_LIKE_OP:        []byte("NOT LIKE"),
+		goqu.REGEXP_LIKE_OP:       []byte("REGEXP BINARY"),
+		goqu.REGEXP_NOT_LIKE_OP:   []byte("NOT REGEXP BINARY"),
+		goqu.REGEXP_I_LIKE_OP:     []byte("REGEXP"),
+		goqu.REGEXP_NOT_I_LIKE_OP: []byte("NOT REGEXP"),
+	}
+)
+
+type DatasetAdapter struct {
+	*goqu.DefaultAdapter
+}
+
+func (me *DatasetAdapter) SupportsReturn() bool {
+	return false
+}
+
+func (me *DatasetAdapter) SupportsLimitOnDelete() bool {
+	return true
+}
+
+func (me *DatasetAdapter) SupportsLimitOnUpdate() bool {
+	return true
+}
+
+func (me *DatasetAdapter) SupportsOrderByOnDelete() bool {
+	return true
+}
+
+func (me *DatasetAdapter) SupportsOrderByOnUpdate() bool {
+	return true
+}
+
+func (me *DatasetAdapter) LiteralString(buf *goqu.SqlBuilder, s string) error {
+	if buf.IsPrepared {
+		return me.PlaceHolderSql(buf, s)
+	}
+	buf.WriteRune(singlq_quote)
+	for _, char := range s {
+		if char == '\'' { // single quote: ' -> \'
+			buf.WriteString("\\'")
+		} else if char == '"' { // double quote: " -> \"
+			buf.WriteString("\\\"")
+		} else if char == '\\' { // slash: \ -> "\\"
+			buf.WriteString("\\\\")
+		} else if char == '\n' { // control: newline: \n -> "\n"
+			buf.WriteString("\\n")
+		} else if char == '\r' { // control: return: \r -> "\r"
+			buf.WriteString("\\r")
+		} else if char == 0 { // control: NUL: 0 -> "\x00"
+			buf.WriteString("\\x00")
+		} else if char == 0x1a { // control: \x1a -> "\x1a"
+			buf.WriteString("\\x1a")
+		} else {
+			buf.WriteRune(char)
+		}
+	}
+	buf.WriteRune(singlq_quote)
+	return nil
+}
+
+func newDatasetAdapter(ds *goqu.Dataset) goqu.Adapter {
+	def := goqu.NewDefaultAdapter(ds).(*goqu.DefaultAdapter)
+	def.PlaceHolderRune = placeholder_rune
+	def.IncludePlaceholderNum = false
+	def.QuoteRune = quote_rune
+	def.DefaultValuesFragment = default_values_frag
+	def.True = sqlite3_true
+	def.False = sqlite3_false
+	def.TimeFormat = time_format
+	def.BooleanOperatorLookup = operator_lookup
+	return &DatasetAdapter{def}
+}
+
+func init() {
+	goqu.RegisterAdapter("sqlite3", newDatasetAdapter)
+}