├── .gitignore ├── .travis.yml ├── CHANGELOG.md ├── LICENSE.txt ├── README.md ├── build.gradle ├── config └── checkstyle │ └── checkstyle.xml ├── gradle └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat ├── settings.gradle └── src ├── main └── java │ └── com │ └── alexfu │ └── sqlitequerybuilder │ ├── api │ ├── Builder.java │ ├── Column.java │ ├── ColumnConstraint.java │ ├── ColumnType.java │ ├── ObjectType.java │ ├── SQLiteQueryBuilder.java │ └── SelectType.java │ ├── builder │ ├── CreateTableSegmentBuilder.java │ ├── DropSegmentBuilder.java │ ├── JoinOnBuilder.java │ ├── JoinType.java │ ├── SegmentBuilder.java │ ├── SelectAndBuilder.java │ ├── SelectBuilder.java │ ├── SelectFieldBuilder.java │ ├── SelectFromBuilder.java │ ├── SelectGroupByBuilder.java │ ├── SelectHavingBuilder.java │ ├── SelectJoinBuilder.java │ ├── SelectLimitBuilder.java │ ├── SelectOrderByBuilder.java │ ├── SelectOrderTermBuilder.java │ ├── SelectTypeBuilder.java │ ├── SelectWhereBuilder.java │ ├── delete │ │ ├── DeleteBuilder.java │ │ ├── DeleteFromBuilder.java │ │ └── DeleteWhereBuilder.java │ └── insert │ │ ├── InsertBuilder.java │ │ ├── InsertColumnsBuilder.java │ │ ├── InsertIntoBuilder.java │ │ └── InsertValuesBuilder.java │ └── utils │ ├── DateUtils.java │ ├── Preconditions.java │ └── StringUtils.java └── test └── java └── com └── alexfu └── sqlitequerybuilder ├── CreateTableTest.java ├── DeleteTest.java ├── DropTest.java ├── InsertTest.java ├── SelectTest.java └── StringUtilsTest.java /.gitignore: -------------------------------------------------------------------------------- 1 | # IntelliJ IDEA 2 | .idea 3 | *.iml 4 | 5 | # Gradle 6 | .gradle 7 | build 8 | /bin/ 9 | *.classpath 10 | *.project 11 | *.prefs 12 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: java 2 | notifications: 3 | webhooks: 4 | urls: 5 | - https://webhooks.gitter.im/e/a143efa81f451ac87182 6 | on_success: always # options: [always|never|change] default: always 7 | on_failure: always # options: [always|never|change] default: always 8 | on_start: true # default: false 9 | after_success: 10 | - ./gradlew jacocoTestReport coveralls 11 | 12 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Change Log 2 | 3 | ## [0.3.0](https://github.com/alexfu/SQLiteQueryBuilder/tree/0.3.0) (2016-06-16) 4 | [Full Changelog](https://github.com/alexfu/SQLiteQueryBuilder/compare/0.2.0...0.3.0) 5 | 6 | **Fixed bugs:** 7 | 8 | - Can't use and method twice after where [\#38](https://github.com/alexfu/SQLiteQueryBuilder/issues/38) 9 | - Support DEFAULT [\#28](https://github.com/alexfu/SQLiteQueryBuilder/issues/28) 10 | - Support AUTOINCREMENT [\#25](https://github.com/alexfu/SQLiteQueryBuilder/issues/25) 11 | - Implement chainable AND clause [\#40](https://github.com/alexfu/SQLiteQueryBuilder/pull/40) ([alexfu](https://github.com/alexfu)) 12 | 13 | **Closed issues:** 14 | 15 | - Add a CHANGELOG [\#45](https://github.com/alexfu/SQLiteQueryBuilder/issues/45) 16 | - Add information about licensing [\#37](https://github.com/alexfu/SQLiteQueryBuilder/issues/37) 17 | - Add argument checks and fail early [\#9](https://github.com/alexfu/SQLiteQueryBuilder/issues/9) 18 | 19 | **Merged pull requests:** 20 | 21 | - Add license [\#44](https://github.com/alexfu/SQLiteQueryBuilder/pull/44) ([alexfu](https://github.com/alexfu)) 22 | - Update repositories from mavenCentral to jcenter. [\#42](https://github.com/alexfu/SQLiteQueryBuilder/pull/42) ([monxalo](https://github.com/monxalo)) 23 | - Support for insert statements [\#36](https://github.com/alexfu/SQLiteQueryBuilder/pull/36) ([alexfu](https://github.com/alexfu)) 24 | - Support AUTOINCREMENT [\#35](https://github.com/alexfu/SQLiteQueryBuilder/pull/35) ([alexfu](https://github.com/alexfu)) 25 | - Support DEFAULT [\#34](https://github.com/alexfu/SQLiteQueryBuilder/pull/34) ([alexfu](https://github.com/alexfu)) 26 | - Support preconditions [\#30](https://github.com/alexfu/SQLiteQueryBuilder/pull/30) ([alexfu](https://github.com/alexfu)) 27 | - Support DELETE [\#29](https://github.com/alexfu/SQLiteQueryBuilder/pull/29) ([alexfu](https://github.com/alexfu)) 28 | 29 | ## [0.2.0](https://github.com/alexfu/SQLiteQueryBuilder/tree/0.2.0) (2015-07-25) 30 | [Full Changelog](https://github.com/alexfu/SQLiteQueryBuilder/compare/0.1.1...0.2.0) 31 | 32 | **Fixed bugs:** 33 | 34 | - Cannot call limit after where [\#23](https://github.com/alexfu/SQLiteQueryBuilder/issues/23) 35 | 36 | **Closed issues:** 37 | 38 | - Add checkstyle [\#26](https://github.com/alexfu/SQLiteQueryBuilder/issues/26) 39 | - Add "TEMP/TEMPORARY" to CREATE TABLE statement [\#12](https://github.com/alexfu/SQLiteQueryBuilder/issues/12) 40 | 41 | **Merged pull requests:** 42 | 43 | - Add checkstyle [\#27](https://github.com/alexfu/SQLiteQueryBuilder/pull/27) ([alexfu](https://github.com/alexfu)) 44 | - Add TEMP keyword to CREATE TABLE statement [\#24](https://github.com/alexfu/SQLiteQueryBuilder/pull/24) ([shadeven](https://github.com/shadeven)) 45 | - Better memory efficient StringUtils join. [\#22](https://github.com/alexfu/SQLiteQueryBuilder/pull/22) ([monxalo](https://github.com/monxalo)) 46 | - Guide user to the correct method call in DROP statement [\#21](https://github.com/alexfu/SQLiteQueryBuilder/pull/21) ([shadeven](https://github.com/shadeven)) 47 | - Change return type to SegmentBuidler. [\#19](https://github.com/alexfu/SQLiteQueryBuilder/pull/19) ([monxalo](https://github.com/monxalo)) 48 | - Add jitpack usage. [\#18](https://github.com/alexfu/SQLiteQueryBuilder/pull/18) ([monxalo](https://github.com/monxalo)) 49 | - Support drop table [\#17](https://github.com/alexfu/SQLiteQueryBuilder/pull/17) ([shadeven](https://github.com/shadeven)) 50 | 51 | ## [0.1.1](https://github.com/alexfu/SQLiteQueryBuilder/tree/0.1.1) (2015-06-27) 52 | [Full Changelog](https://github.com/alexfu/SQLiteQueryBuilder/compare/0.1.0...0.1.1) 53 | 54 | ## [0.1.0](https://github.com/alexfu/SQLiteQueryBuilder/tree/0.1.0) (2015-06-17) 55 | **Closed issues:** 56 | 57 | - Support for other Join operators [\#14](https://github.com/alexfu/SQLiteQueryBuilder/issues/14) 58 | - Add create builder [\#13](https://github.com/alexfu/SQLiteQueryBuilder/issues/13) 59 | - Add "IF NOT EXISTS" condition to CREATE TABLE statement [\#10](https://github.com/alexfu/SQLiteQueryBuilder/issues/10) 60 | - Use AssertJ for assertions [\#6](https://github.com/alexfu/SQLiteQueryBuilder/issues/6) 61 | - Add project to TravisCI [\#5](https://github.com/alexfu/SQLiteQueryBuilder/issues/5) 62 | - Add Jacoco plugin for code coverage reporting [\#4](https://github.com/alexfu/SQLiteQueryBuilder/issues/4) 63 | - Improve statement string builder [\#2](https://github.com/alexfu/SQLiteQueryBuilder/issues/2) 64 | - Support CREATE statements [\#1](https://github.com/alexfu/SQLiteQueryBuilder/issues/1) 65 | 66 | **Merged pull requests:** 67 | 68 | - Having clause. [\#16](https://github.com/alexfu/SQLiteQueryBuilder/pull/16) ([monxalo](https://github.com/monxalo)) 69 | - Join operators. [\#15](https://github.com/alexfu/SQLiteQueryBuilder/pull/15) ([monxalo](https://github.com/monxalo)) 70 | - Add "IF NOT EXISTS" clause to CREATE TABLE [\#11](https://github.com/alexfu/SQLiteQueryBuilder/pull/11) ([shadeven](https://github.com/shadeven)) 71 | - Improve statement string builder [\#8](https://github.com/alexfu/SQLiteQueryBuilder/pull/8) ([alexfu](https://github.com/alexfu)) 72 | - Pull Request for CREATE statements [\#3](https://github.com/alexfu/SQLiteQueryBuilder/pull/3) ([shadeven](https://github.com/shadeven)) 73 | 74 | 75 | 76 | \* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)* -------------------------------------------------------------------------------- /LICENSE.txt: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2016 Alex Fu 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # SQLiteQueryBuilder 2 | 3 | [![Build Status](https://travis-ci.org/alexfu/SQLiteQueryBuilder.svg?branch=master)](https://travis-ci.org/alexfu/SQLiteQueryBuilder) 4 | [![Coverage Status](https://coveralls.io/repos/alexfu/SQLiteQueryBuilder/badge.svg?branch=master)](https://coveralls.io/r/alexfu/SQLiteQueryBuilder?branch=master) 5 | [![Join the chat at https://gitter.im/alexfu/SQLiteQueryBuilder](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/alexfu/SQLiteQueryBuilder?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) 6 | 7 | This project is aimed at providing a simple API to build SQLite query statements. This library does nothing but build statements; it's not an ORM. The API syntax is inspired from the jOOQ library. 8 | 9 | Currently, SQLiteQueryBuilder is under active development so you may find some features missing. If this is the case, please file an issue or open a pull request. 10 | 11 | ## Motivation 12 | Although this project is written in Java and bears no dependencies to external frameworks (so far), it is/was developed specifically to be used on the Android platform. There are a few reasons why I started this project... 13 | 14 | - Building SQLite statements in pure Java can be cumbersome and very unreadable at times 15 | - Androids own SQLiteQueryBuilder is also cumbersome to use at times. 16 | - Although the jOOQ library has a great API for building SQL statements, it comes with an entire suite of tools to build statements, connect to databases, write/read models to/from databases, etc. Due to the current nature of Dalvik (Androids application VM), there is a 64k method reference limit. jOOQ can contain over 10,000 referenced methods when in use. This may not seem like much in comparison to the limit, but if you consider other large libraries commonly used (such as Guava and Google Play Services), hitting that 64k limit becomes much easier. 17 | 18 | ## Usage 19 | ```java 20 | String sql = SQLiteQueryBuilder 21 | .select("*") 22 | .from("accounts") 23 | .where("id = 1") 24 | .toString(); 25 | ``` 26 | 27 | You can view more examples in the [src/test/java](src/test/java) folder. 28 | 29 | To use this library, add the follow to your gradle build: 30 | 31 | ```groovy 32 | repositories { 33 | maven { 34 | url "https://jitpack.io" 35 | } 36 | } 37 | 38 | dependencies { 39 | compile 'com.github.alexfu:SQLiteQueryBuilder:0.1.1' 40 | } 41 | ``` 42 | -------------------------------------------------------------------------------- /build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'java' 2 | apply plugin: 'maven' 3 | apply plugin: 'jacoco' 4 | apply plugin: 'checkstyle' 5 | apply plugin: 'com.github.kt3k.coveralls' 6 | 7 | group = 'com.github.alexfu' 8 | 9 | buildscript { 10 | repositories { 11 | jcenter() 12 | } 13 | 14 | dependencies { 15 | classpath 'org.kt3k.gradle.plugin:coveralls-gradle-plugin:2.3.1' 16 | } 17 | } 18 | 19 | sourceCompatibility = 1.5 20 | version = '0.3.0' 21 | 22 | repositories { 23 | jcenter() 24 | } 25 | 26 | jacocoTestReport { 27 | reports { 28 | xml.enabled = true // coveralls plugin depends on xml format report 29 | html.enabled = true 30 | } 31 | } 32 | 33 | dependencies { 34 | testCompile 'junit:junit:4.12' 35 | testCompile 'org.assertj:assertj-core:2.0.0' 36 | } 37 | 38 | checkstyle { 39 | toolVersion = '6.7' 40 | } 41 | -------------------------------------------------------------------------------- /config/checkstyle/checkstyle.xml: -------------------------------------------------------------------------------- 1 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/alexfu/SQLiteQueryBuilder/489cc1e215ce01e5801f0454d1e9e4e4b32b3eff/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | #Thu Dec 25 11:51:50 EST 2014 2 | distributionBase=GRADLE_USER_HOME 3 | distributionPath=wrapper/dists 4 | zipStoreBase=GRADLE_USER_HOME 5 | zipStorePath=wrapper/dists 6 | distributionUrl=https\://services.gradle.org/distributions/gradle-2.1-all.zip 7 | -------------------------------------------------------------------------------- /gradlew: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | ############################################################################## 4 | ## 5 | ## Gradle start up script for UN*X 6 | ## 7 | ############################################################################## 8 | 9 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. 10 | DEFAULT_JVM_OPTS="" 11 | 12 | APP_NAME="Gradle" 13 | APP_BASE_NAME=`basename "$0"` 14 | 15 | # Use the maximum available, or set MAX_FD != -1 to use that value. 16 | MAX_FD="maximum" 17 | 18 | warn ( ) { 19 | echo "$*" 20 | } 21 | 22 | die ( ) { 23 | echo 24 | echo "$*" 25 | echo 26 | exit 1 27 | } 28 | 29 | # OS specific support (must be 'true' or 'false'). 30 | cygwin=false 31 | msys=false 32 | darwin=false 33 | case "`uname`" in 34 | CYGWIN* ) 35 | cygwin=true 36 | ;; 37 | Darwin* ) 38 | darwin=true 39 | ;; 40 | MINGW* ) 41 | msys=true 42 | ;; 43 | esac 44 | 45 | # For Cygwin, ensure paths are in UNIX format before anything is touched. 46 | if $cygwin ; then 47 | [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"` 48 | fi 49 | 50 | # Attempt to set APP_HOME 51 | # Resolve links: $0 may be a link 52 | PRG="$0" 53 | # Need this for relative symlinks. 54 | while [ -h "$PRG" ] ; do 55 | ls=`ls -ld "$PRG"` 56 | link=`expr "$ls" : '.*-> \(.*\)$'` 57 | if expr "$link" : '/.*' > /dev/null; then 58 | PRG="$link" 59 | else 60 | PRG=`dirname "$PRG"`"/$link" 61 | fi 62 | done 63 | SAVED="`pwd`" 64 | cd "`dirname \"$PRG\"`/" >&- 65 | APP_HOME="`pwd -P`" 66 | cd "$SAVED" >&- 67 | 68 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar 69 | 70 | # Determine the Java command to use to start the JVM. 71 | if [ -n "$JAVA_HOME" ] ; then 72 | if [ -x "$JAVA_HOME/jre/sh/java" ] ; then 73 | # IBM's JDK on AIX uses strange locations for the executables 74 | JAVACMD="$JAVA_HOME/jre/sh/java" 75 | else 76 | JAVACMD="$JAVA_HOME/bin/java" 77 | fi 78 | if [ ! -x "$JAVACMD" ] ; then 79 | die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME 80 | 81 | Please set the JAVA_HOME variable in your environment to match the 82 | location of your Java installation." 83 | fi 84 | else 85 | JAVACMD="java" 86 | which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 87 | 88 | Please set the JAVA_HOME variable in your environment to match the 89 | location of your Java installation." 90 | fi 91 | 92 | # Increase the maximum file descriptors if we can. 93 | if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then 94 | MAX_FD_LIMIT=`ulimit -H -n` 95 | if [ $? -eq 0 ] ; then 96 | if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then 97 | MAX_FD="$MAX_FD_LIMIT" 98 | fi 99 | ulimit -n $MAX_FD 100 | if [ $? -ne 0 ] ; then 101 | warn "Could not set maximum file descriptor limit: $MAX_FD" 102 | fi 103 | else 104 | warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" 105 | fi 106 | fi 107 | 108 | # For Darwin, add options to specify how the application appears in the dock 109 | if $darwin; then 110 | GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" 111 | fi 112 | 113 | # For Cygwin, switch paths to Windows format before running java 114 | if $cygwin ; then 115 | APP_HOME=`cygpath --path --mixed "$APP_HOME"` 116 | CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` 117 | 118 | # We build the pattern for arguments to be converted via cygpath 119 | ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` 120 | SEP="" 121 | for dir in $ROOTDIRSRAW ; do 122 | ROOTDIRS="$ROOTDIRS$SEP$dir" 123 | SEP="|" 124 | done 125 | OURCYGPATTERN="(^($ROOTDIRS))" 126 | # Add a user-defined pattern to the cygpath arguments 127 | if [ "$GRADLE_CYGPATTERN" != "" ] ; then 128 | OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" 129 | fi 130 | # Now convert the arguments - kludge to limit ourselves to /bin/sh 131 | i=0 132 | for arg in "$@" ; do 133 | CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` 134 | CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option 135 | 136 | if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition 137 | eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` 138 | else 139 | eval `echo args$i`="\"$arg\"" 140 | fi 141 | i=$((i+1)) 142 | done 143 | case $i in 144 | (0) set -- ;; 145 | (1) set -- "$args0" ;; 146 | (2) set -- "$args0" "$args1" ;; 147 | (3) set -- "$args0" "$args1" "$args2" ;; 148 | (4) set -- "$args0" "$args1" "$args2" "$args3" ;; 149 | (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; 150 | (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; 151 | (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; 152 | (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; 153 | (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; 154 | esac 155 | fi 156 | 157 | # Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules 158 | function splitJvmOpts() { 159 | JVM_OPTS=("$@") 160 | } 161 | eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS 162 | JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME" 163 | 164 | exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@" 165 | -------------------------------------------------------------------------------- /gradlew.bat: -------------------------------------------------------------------------------- 1 | @if "%DEBUG%" == "" @echo off 2 | @rem ########################################################################## 3 | @rem 4 | @rem Gradle startup script for Windows 5 | @rem 6 | @rem ########################################################################## 7 | 8 | @rem Set local scope for the variables with windows NT shell 9 | if "%OS%"=="Windows_NT" setlocal 10 | 11 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. 12 | set DEFAULT_JVM_OPTS= 13 | 14 | set DIRNAME=%~dp0 15 | if "%DIRNAME%" == "" set DIRNAME=. 16 | set APP_BASE_NAME=%~n0 17 | set APP_HOME=%DIRNAME% 18 | 19 | @rem Find java.exe 20 | if defined JAVA_HOME goto findJavaFromJavaHome 21 | 22 | set JAVA_EXE=java.exe 23 | %JAVA_EXE% -version >NUL 2>&1 24 | if "%ERRORLEVEL%" == "0" goto init 25 | 26 | echo. 27 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 28 | echo. 29 | echo Please set the JAVA_HOME variable in your environment to match the 30 | echo location of your Java installation. 31 | 32 | goto fail 33 | 34 | :findJavaFromJavaHome 35 | set JAVA_HOME=%JAVA_HOME:"=% 36 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe 37 | 38 | if exist "%JAVA_EXE%" goto init 39 | 40 | echo. 41 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 42 | echo. 43 | echo Please set the JAVA_HOME variable in your environment to match the 44 | echo location of your Java installation. 45 | 46 | goto fail 47 | 48 | :init 49 | @rem Get command-line arguments, handling Windowz variants 50 | 51 | if not "%OS%" == "Windows_NT" goto win9xME_args 52 | if "%@eval[2+2]" == "4" goto 4NT_args 53 | 54 | :win9xME_args 55 | @rem Slurp the command line arguments. 56 | set CMD_LINE_ARGS= 57 | set _SKIP=2 58 | 59 | :win9xME_args_slurp 60 | if "x%~1" == "x" goto execute 61 | 62 | set CMD_LINE_ARGS=%* 63 | goto execute 64 | 65 | :4NT_args 66 | @rem Get arguments from the 4NT Shell from JP Software 67 | set CMD_LINE_ARGS=%$ 68 | 69 | :execute 70 | @rem Setup the command line 71 | 72 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar 73 | 74 | @rem Execute Gradle 75 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% 76 | 77 | :end 78 | @rem End local scope for the variables with windows NT shell 79 | if "%ERRORLEVEL%"=="0" goto mainEnd 80 | 81 | :fail 82 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of 83 | rem the _cmd.exe /c_ return code! 84 | if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 85 | exit /b 1 86 | 87 | :mainEnd 88 | if "%OS%"=="Windows_NT" endlocal 89 | 90 | :omega 91 | -------------------------------------------------------------------------------- /settings.gradle: -------------------------------------------------------------------------------- 1 | rootProject.name = 'SQLiteQueryBuilder' 2 | 3 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/api/Builder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.api; 2 | 3 | public interface Builder { 4 | public String build(); 5 | } 6 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/api/Column.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.api; 2 | 3 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 4 | 5 | public class Column implements Builder { 6 | 7 | private final String name; 8 | private final ColumnType type; 9 | private final ColumnConstraint constraint; 10 | private final String defaultValue; 11 | 12 | public Column(String name, ColumnType type) { 13 | this(name, type, null); 14 | } 15 | 16 | public Column(String name, ColumnType type, ColumnConstraint constraint) { 17 | this(name, type, constraint, null); 18 | } 19 | 20 | public Column(String name, ColumnType type, ColumnConstraint constraint, String defaultValue) { 21 | this.name = name; 22 | this.type = type; 23 | this.constraint = constraint; 24 | this.defaultValue = defaultValue; 25 | } 26 | 27 | @Override 28 | public String build() { 29 | String result = StringUtils.join(" ", name, type.toString()); 30 | if (constraint != null) { 31 | result = StringUtils.join(" ", result, constraint.toString()); 32 | } 33 | if (defaultValue != null) { 34 | result = StringUtils.join(" ", result, "DEFAULT", defaultValue); 35 | } 36 | return result; 37 | } 38 | 39 | @Override 40 | public String toString() { 41 | return build(); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/api/ColumnConstraint.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.api; 2 | 3 | public enum ColumnConstraint { 4 | 5 | PRIMARY_KEY("PRIMARY KEY"), 6 | PRIMARY_KEY_AUTO_INCREMENT("PRIMARY KEY AUTOINCREMENT"), 7 | UNIQUE("UNIQUE"), 8 | CHECK("CHECK"), 9 | FOREIGN_KEY("FOREIGN KEY"), 10 | NOT_NULL("NOT NULL"); 11 | 12 | private String name; 13 | 14 | private ColumnConstraint(String name) { 15 | this.name = name; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return name; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/api/ColumnType.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.api; 2 | 3 | public enum ColumnType { 4 | 5 | TEXT, 6 | NUMERIC, 7 | INTEGER, 8 | REAL, 9 | NONE 10 | } 11 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/api/ObjectType.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.api; 2 | 3 | /** 4 | * Created by Steven on 30/06/2015. 5 | */ 6 | public enum ObjectType { 7 | TABLE, 8 | VIEW, 9 | TRIGGER, 10 | INDEX 11 | } 12 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/api/SQLiteQueryBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.api; 2 | 3 | import com.alexfu.sqlitequerybuilder.builder.*; 4 | import com.alexfu.sqlitequerybuilder.builder.delete.DeleteBuilder; 5 | import com.alexfu.sqlitequerybuilder.builder.insert.InsertBuilder; 6 | 7 | public class SQLiteQueryBuilder { 8 | 9 | public static InsertBuilder insert() { 10 | return new InsertBuilder(); 11 | } 12 | 13 | public static SelectBuilder select(String... fields) { 14 | return new SelectFieldBuilder(fields); 15 | } 16 | 17 | public static SelectBuilder select(SelectType type) { 18 | return new SelectTypeBuilder(type); 19 | } 20 | 21 | public static CreateTableSegmentBuilder create() { 22 | return new CreateTableSegmentBuilder(); 23 | } 24 | 25 | public static DropSegmentBuilder drop() { 26 | return new DropSegmentBuilder(); 27 | } 28 | 29 | public static DeleteBuilder delete() { 30 | return new DeleteBuilder(); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/api/SelectType.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.api; 2 | 3 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 4 | 5 | public class SelectType implements Builder { 6 | 7 | private enum Type { 8 | DISTINCT, ALL 9 | } 10 | 11 | private Type type; 12 | private String[] fields; 13 | 14 | private SelectType(Type type, String... fields) { 15 | this.type = type; 16 | this.fields = fields; 17 | } 18 | 19 | public static SelectType DISTINCT(String... fields) { 20 | return new SelectType(Type.DISTINCT, fields); 21 | } 22 | 23 | public static SelectType ALL(String... fields) { 24 | return new SelectType(Type.ALL, fields); 25 | } 26 | 27 | @Override 28 | public String build() { 29 | return StringUtils.join(" ", type.toString(), StringUtils.join(",", fields)); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/CreateTableSegmentBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder; 2 | 3 | import com.alexfu.sqlitequerybuilder.api.Column; 4 | import com.alexfu.sqlitequerybuilder.utils.Preconditions; 5 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 6 | 7 | import java.util.ArrayList; 8 | import java.util.List; 9 | 10 | public class CreateTableSegmentBuilder extends SegmentBuilder { 11 | 12 | private boolean temp; 13 | private boolean ifNotExists; 14 | private String name; 15 | private final List definitions = new ArrayList(); 16 | 17 | public CreateTableSegmentBuilder() {} 18 | 19 | public CreateTableSegmentBuilder temp() { 20 | temp = true; 21 | return this; 22 | } 23 | 24 | public CreateTableSegmentBuilder ifNotExists() { 25 | ifNotExists = true; 26 | return this; 27 | } 28 | 29 | public CreateTableSegmentBuilder column(Column column) { 30 | Preconditions.checkArgument(column != null, "A non-null column is required."); 31 | definitions.add(column); 32 | return this; 33 | } 34 | 35 | public CreateTableSegmentBuilder table(String name) { 36 | Preconditions.checkNotEmpty(name, "Table name can not be empty."); 37 | this.name = name; 38 | return this; 39 | } 40 | 41 | @Override 42 | public String build() { 43 | String head = "CREATE " 44 | + (temp ? "TEMP " : "") 45 | + "TABLE" 46 | + (ifNotExists ? " IF NOT EXISTS" : ""); 47 | 48 | String tail = name + "(" + StringUtils.join(",", definitions.toArray()) + ")"; 49 | 50 | return StringUtils.join(" ", head, tail); 51 | } 52 | 53 | } 54 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/DropSegmentBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder; 2 | 3 | import com.alexfu.sqlitequerybuilder.api.ObjectType; 4 | import com.alexfu.sqlitequerybuilder.utils.Preconditions; 5 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 6 | 7 | /** 8 | * @author Steven Wu 9 | */ 10 | public class DropSegmentBuilder extends SegmentBuilder { 11 | 12 | private boolean ifExists; 13 | private ObjectType type; 14 | private String name; 15 | 16 | private DropSegmentBuilder(ObjectType type, String name) { 17 | this.type = type; 18 | this.name = name; 19 | } 20 | 21 | public DropSegmentBuilder() { 22 | } 23 | 24 | public DropSegmentBuilder table(String table) { 25 | Preconditions.checkArgument(table != null, "Table name cannot be null"); 26 | return new DropSegmentBuilder(ObjectType.TABLE, table); 27 | } 28 | 29 | public DropSegmentBuilder view(String view) { 30 | Preconditions.checkArgument(view != null, "View name cannot be null"); 31 | return new DropSegmentBuilder(ObjectType.VIEW, view); 32 | } 33 | 34 | public DropSegmentBuilder index(String index) { 35 | Preconditions.checkArgument(index != null, "Index name cannot be null"); 36 | return new DropSegmentBuilder(ObjectType.INDEX, index); 37 | } 38 | 39 | public DropSegmentBuilder trigger(String trigger) { 40 | Preconditions.checkArgument(trigger != null, "Trigger name cannot be null"); 41 | return new DropSegmentBuilder(ObjectType.TRIGGER, trigger); 42 | } 43 | 44 | public SegmentBuilder ifExists() { 45 | ifExists = true; 46 | return this; 47 | } 48 | 49 | @Override 50 | public String build() { 51 | String statement = "DROP " + type + (ifExists ? " IF EXISTS" : ""); 52 | return StringUtils.join(" ", statement, name); 53 | } 54 | 55 | } 56 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/JoinOnBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder; 2 | 3 | import com.alexfu.sqlitequerybuilder.utils.Preconditions; 4 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 5 | 6 | public class JoinOnBuilder extends SegmentBuilder { 7 | 8 | private SelectJoinBuilder prefix; 9 | private String condition; 10 | 11 | public JoinOnBuilder(SelectJoinBuilder prefix, String condition) { 12 | this.prefix = prefix; 13 | this.condition = condition; 14 | } 15 | 16 | public SelectWhereBuilder where(String condition) { 17 | Preconditions.checkArgument(condition != null, "Condition cannot be null"); 18 | return new SelectWhereBuilder(this, condition); 19 | } 20 | 21 | public SelectJoinBuilder join(String table) { 22 | Preconditions.checkArgument(table != null, "Table name cannot be null"); 23 | return new SelectJoinBuilder(this, table, JoinType.JOIN); 24 | } 25 | 26 | @Override 27 | public String build() { 28 | return StringUtils.join(" ", prefix.build(), "ON", condition); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/JoinType.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder; 2 | 3 | public enum JoinType { 4 | JOIN("JOIN"), 5 | CROSS_JOIN("CROSS JOIN"), 6 | LEFT_OUTER_JOIN("LEFT OUTER JOIN"), 7 | NATURAL_JOIN("NATURAL JOIN"), 8 | NATURAL_LEFT_OUTER_JOIN("NATURAL LEFT OUTER JOIN"); 9 | 10 | private final String sql; 11 | 12 | JoinType(String sql) { 13 | this.sql = sql; 14 | } 15 | 16 | public final String toSQL() { 17 | return sql; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/SegmentBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder; 2 | 3 | import com.alexfu.sqlitequerybuilder.api.Builder; 4 | 5 | public abstract class SegmentBuilder implements Builder { 6 | @Override 7 | public String toString() { 8 | return build(); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/SelectAndBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder; 2 | 3 | import com.alexfu.sqlitequerybuilder.api.Builder; 4 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 5 | 6 | public class SelectAndBuilder extends SegmentBuilder { 7 | 8 | private Builder prefix; 9 | private String condition; 10 | 11 | public SelectAndBuilder(Builder prefix, String condition) { 12 | this.prefix = prefix; 13 | this.condition = condition; 14 | } 15 | 16 | public SelectAndBuilder and(String condition) { 17 | return new SelectAndBuilder(this, condition); 18 | } 19 | 20 | @Override 21 | public String build() { 22 | return StringUtils.join(" ", prefix.build(), "AND", condition); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/SelectBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder; 2 | 3 | import com.alexfu.sqlitequerybuilder.utils.Preconditions; 4 | 5 | public abstract class SelectBuilder extends SegmentBuilder { 6 | public SelectFromBuilder from(String table) { 7 | Preconditions.checkArgument(table != null, "Table cannot be null"); 8 | return new SelectFromBuilder(this, table); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/SelectFieldBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder; 2 | 3 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 4 | 5 | public class SelectFieldBuilder extends SelectBuilder { 6 | 7 | private String[] fields; 8 | 9 | public SelectFieldBuilder(String... fields) { 10 | this.fields = fields; 11 | } 12 | 13 | @Override 14 | public String build() { 15 | return StringUtils.join(" ", "SELECT", StringUtils.join(",", fields)); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/SelectFromBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder; 2 | 3 | import com.alexfu.sqlitequerybuilder.utils.Preconditions; 4 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 5 | 6 | public class SelectFromBuilder extends SegmentBuilder { 7 | 8 | private SelectBuilder prefix; 9 | private String[] tables; 10 | 11 | public SelectFromBuilder(SelectBuilder prefix, String... tables) { 12 | this.prefix = prefix; 13 | this.tables = tables; 14 | } 15 | 16 | public SelectWhereBuilder where(String condition) { 17 | Preconditions.checkArgument(condition != null, "Condition cannot be null"); 18 | return new SelectWhereBuilder(this, condition); 19 | } 20 | 21 | public SelectJoinBuilder join(String table) { 22 | Preconditions.checkArgument(table != null, "Table cannot be null"); 23 | return new SelectJoinBuilder(this, table, JoinType.JOIN); 24 | } 25 | 26 | public SelectJoinBuilder leftOuterJoin(String table) { 27 | Preconditions.checkArgument(table != null, "Table cannot be null"); 28 | return new SelectJoinBuilder(this, table, JoinType.LEFT_OUTER_JOIN); 29 | } 30 | 31 | public SelectJoinBuilder crossJoin(String table) { 32 | Preconditions.checkArgument(table != null, "Table cannot be null"); 33 | return new SelectJoinBuilder(this, table, JoinType.CROSS_JOIN); 34 | } 35 | 36 | public SelectJoinBuilder naturalJoin(String table) { 37 | Preconditions.checkArgument(table != null, "Table cannot be null"); 38 | return new SelectJoinBuilder(this, table, JoinType.NATURAL_JOIN); 39 | } 40 | 41 | public SelectJoinBuilder naturalLeftOuterJoin(String table) { 42 | Preconditions.checkArgument(table != null, "Table cannot be null"); 43 | return new SelectJoinBuilder(this, table, JoinType.NATURAL_LEFT_OUTER_JOIN); 44 | } 45 | 46 | public SelectOrderByBuilder orderBy(String column) { 47 | Preconditions.checkArgument(column != null, "Column cannot be null"); 48 | return new SelectOrderByBuilder(this, column); 49 | } 50 | 51 | public SelectGroupByBuilder groupBy(String column) { 52 | Preconditions.checkArgument(column != null, "Column cannot be null"); 53 | return new SelectGroupByBuilder(this, column); 54 | } 55 | 56 | public SelectLimitBuilder limit(int limit) { 57 | return new SelectLimitBuilder(this, limit); 58 | } 59 | 60 | @Override 61 | public String build() { 62 | return StringUtils.join(" ", prefix.build(), "FROM", StringUtils.join(",", tables)); 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/SelectGroupByBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder; 2 | 3 | import com.alexfu.sqlitequerybuilder.utils.Preconditions; 4 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 5 | 6 | public class SelectGroupByBuilder extends SegmentBuilder { 7 | 8 | private SelectFromBuilder prefix; 9 | private String column; 10 | 11 | public SelectGroupByBuilder(SelectFromBuilder prefix, String column) { 12 | this.prefix = prefix; 13 | this.column = column; 14 | } 15 | 16 | public SelectHavingBuilder having(String condition) { 17 | Preconditions.checkArgument(condition != null, "Condition cannot be null"); 18 | return new SelectHavingBuilder(this, condition); 19 | } 20 | 21 | @Override 22 | public String build() { 23 | return StringUtils.join(" ", prefix.build(), "GROUP BY", column); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/SelectHavingBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder; 2 | 3 | import com.alexfu.sqlitequerybuilder.utils.Preconditions; 4 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 5 | 6 | public class SelectHavingBuilder extends SegmentBuilder { 7 | private SelectGroupByBuilder prefix; 8 | private String condition; 9 | 10 | public SelectHavingBuilder(SelectGroupByBuilder prefix, String condition) { 11 | this.prefix = prefix; 12 | this.condition = condition; 13 | } 14 | 15 | public SelectOrderByBuilder orderBy(String column) { 16 | Preconditions.checkArgument(column != null, "Column cannot be null"); 17 | return new SelectOrderByBuilder(this, column); 18 | } 19 | 20 | public SelectLimitBuilder limit(int limit) { 21 | return new SelectLimitBuilder(this, limit); 22 | } 23 | 24 | @Override 25 | public String build() { 26 | return StringUtils.join(" ", prefix.build(), "HAVING", condition); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/SelectJoinBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder; 2 | 3 | import com.alexfu.sqlitequerybuilder.api.Builder; 4 | import com.alexfu.sqlitequerybuilder.utils.Preconditions; 5 | 6 | import static com.alexfu.sqlitequerybuilder.utils.StringUtils.join; 7 | 8 | public class SelectJoinBuilder extends SegmentBuilder { 9 | 10 | private Builder prefix; 11 | private String table; 12 | private JoinType joinType; 13 | 14 | public SelectJoinBuilder(Builder prefix, String table, JoinType joinType) { 15 | this.prefix = prefix; 16 | this.table = table; 17 | this.joinType = joinType; 18 | } 19 | 20 | public JoinOnBuilder on(String condition) { 21 | Preconditions.checkArgument(condition != null, "Condition cannot be null"); 22 | return new JoinOnBuilder(this, condition); 23 | } 24 | 25 | @Override 26 | public String build() { 27 | return join(" ", prefix.build(), joinType.toSQL(), table); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/SelectLimitBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder; 2 | 3 | import com.alexfu.sqlitequerybuilder.api.Builder; 4 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 5 | 6 | public class SelectLimitBuilder extends SegmentBuilder { 7 | 8 | private Builder prefix; 9 | private int limit = -1; 10 | private int offset = -1; 11 | 12 | public SelectLimitBuilder(Builder prefix, int limit) { 13 | this.prefix = prefix; 14 | this.limit = limit; 15 | } 16 | 17 | public SegmentBuilder offset(int offset) { 18 | this.offset = offset; 19 | return this; 20 | } 21 | 22 | @Override 23 | public String build() { 24 | String offsetString = null; 25 | if (offset != -1) { 26 | offsetString = StringUtils.join(" ", "OFFSET", String.valueOf(offset)); 27 | } 28 | 29 | String result = StringUtils.join(" ", prefix.build(), "LIMIT", String.valueOf(limit)); 30 | if (offsetString != null) { 31 | result = StringUtils.join(" ", result, offsetString); 32 | } 33 | return result; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/SelectOrderByBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder; 2 | 3 | import com.alexfu.sqlitequerybuilder.api.Builder; 4 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 5 | 6 | public class SelectOrderByBuilder extends SegmentBuilder { 7 | 8 | private Builder prefix; 9 | private String column; 10 | 11 | public SelectOrderByBuilder(Builder prefix, String column) { 12 | this.prefix = prefix; 13 | this.column = column; 14 | } 15 | 16 | public SelectOrderTermBuilder asc() { 17 | return new SelectOrderTermBuilder(this, SelectOrderTermBuilder.Term.ASC); 18 | } 19 | 20 | public SelectOrderTermBuilder desc() { 21 | return new SelectOrderTermBuilder(this, SelectOrderTermBuilder.Term.DESC); 22 | } 23 | 24 | @Override 25 | public String build() { 26 | return StringUtils.join(" ", prefix.build(), "ORDER BY", column); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/SelectOrderTermBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder; 2 | 3 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 4 | 5 | public class SelectOrderTermBuilder extends SegmentBuilder { 6 | 7 | public enum Term { 8 | ASC, DESC 9 | } 10 | 11 | private SelectOrderByBuilder prefix; 12 | private Term term; 13 | 14 | public SelectOrderTermBuilder(SelectOrderByBuilder prefix, Term term) { 15 | this.prefix = prefix; 16 | this.term = term; 17 | } 18 | 19 | public SelectLimitBuilder limit(int limit) { 20 | return new SelectLimitBuilder(this, limit); 21 | } 22 | 23 | @Override 24 | public String build() { 25 | return StringUtils.join(" ", prefix.build(), term.toString()); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/SelectTypeBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder; 2 | 3 | import com.alexfu.sqlitequerybuilder.api.SelectType; 4 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 5 | 6 | public class SelectTypeBuilder extends SelectBuilder { 7 | 8 | private SelectType type; 9 | 10 | public SelectTypeBuilder(SelectType type) { 11 | this.type = type; 12 | } 13 | 14 | @Override 15 | public String build() { 16 | return StringUtils.join(" ", "SELECT", type.build()); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/SelectWhereBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder; 2 | 3 | import com.alexfu.sqlitequerybuilder.api.Builder; 4 | import com.alexfu.sqlitequerybuilder.utils.Preconditions; 5 | 6 | import static com.alexfu.sqlitequerybuilder.utils.StringUtils.join; 7 | 8 | public class SelectWhereBuilder extends SegmentBuilder { 9 | 10 | private Builder prefix; 11 | private String condition; 12 | 13 | public SelectWhereBuilder(Builder prefix, String condition) { 14 | this.condition = condition; 15 | this.prefix = prefix; 16 | } 17 | 18 | public SelectAndBuilder and(String condition) { 19 | Preconditions.checkArgument(condition != null, "Condition cannot be null"); 20 | return new SelectAndBuilder(this, condition); 21 | } 22 | 23 | public SelectLimitBuilder limit(int limit) { 24 | return new SelectLimitBuilder(this, limit); 25 | } 26 | 27 | public SelectOrderByBuilder orderBy(String column) { 28 | return new SelectOrderByBuilder(this, column); 29 | } 30 | 31 | @Override 32 | public String build() { 33 | return join(" ", prefix.build(), "WHERE", condition); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/delete/DeleteBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder.delete; 2 | 3 | import com.alexfu.sqlitequerybuilder.builder.SegmentBuilder; 4 | import com.alexfu.sqlitequerybuilder.utils.Preconditions; 5 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 6 | 7 | public class DeleteBuilder extends SegmentBuilder { 8 | public DeleteFromBuilder from(String table) { 9 | Preconditions.checkArgument(table != null, "Table name cannot be null"); 10 | return new DeleteFromBuilder(this, table); 11 | } 12 | 13 | @Override 14 | public String build() { 15 | return StringUtils.join(" ", "DELETE"); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/delete/DeleteFromBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder.delete; 2 | 3 | import com.alexfu.sqlitequerybuilder.builder.SegmentBuilder; 4 | import com.alexfu.sqlitequerybuilder.utils.Preconditions; 5 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 6 | 7 | public class DeleteFromBuilder extends SegmentBuilder { 8 | 9 | private DeleteBuilder prefix; 10 | private String[] tables; 11 | 12 | public DeleteFromBuilder(DeleteBuilder prefix, String... tables) { 13 | this.prefix = prefix; 14 | this.tables = tables; 15 | } 16 | 17 | public DeleteWhereBuilder where(String condition) { 18 | Preconditions.checkArgument(condition != null, "Condition cannot be null"); 19 | return new DeleteWhereBuilder(this, condition); 20 | } 21 | 22 | @Override 23 | public String build() { 24 | return StringUtils.join(" ", prefix.build(), "FROM", StringUtils.join(",", tables)); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/delete/DeleteWhereBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder.delete; 2 | 3 | import com.alexfu.sqlitequerybuilder.api.Builder; 4 | import com.alexfu.sqlitequerybuilder.builder.SegmentBuilder; 5 | 6 | import static com.alexfu.sqlitequerybuilder.utils.StringUtils.join; 7 | 8 | public class DeleteWhereBuilder extends SegmentBuilder { 9 | 10 | private Builder prefix; 11 | private String condition; 12 | 13 | public DeleteWhereBuilder(Builder prefix, String condition) { 14 | this.condition = condition; 15 | this.prefix = prefix; 16 | } 17 | 18 | @Override 19 | public String build() { 20 | return join(" ", prefix.build(), "WHERE", condition); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/insert/InsertBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder.insert; 2 | 3 | import com.alexfu.sqlitequerybuilder.builder.SegmentBuilder; 4 | 5 | import static com.alexfu.sqlitequerybuilder.utils.Preconditions.checkArgument; 6 | 7 | public class InsertBuilder extends SegmentBuilder { 8 | public InsertIntoBuilder into(String table) { 9 | checkArgument(table != null, "Table name cannot be null"); 10 | return new InsertIntoBuilder(this, table); 11 | } 12 | 13 | @Override 14 | public String build() { 15 | return "INSERT INTO"; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/insert/InsertColumnsBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder.insert; 2 | 3 | import com.alexfu.sqlitequerybuilder.builder.SegmentBuilder; 4 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 5 | 6 | import static com.alexfu.sqlitequerybuilder.utils.Preconditions.checkArgument; 7 | 8 | public class InsertColumnsBuilder extends SegmentBuilder { 9 | private final SegmentBuilder predicate; 10 | private final String[] columns; 11 | 12 | public InsertColumnsBuilder(SegmentBuilder predicate, String[] columns) { 13 | this.predicate = predicate; 14 | this.columns = columns; 15 | } 16 | 17 | public InsertValuesBuilder values(Object...values) { 18 | checkArgument(values != null, "Values cannot be null"); 19 | return new InsertValuesBuilder(this, values); 20 | } 21 | 22 | @Override 23 | public String build() { 24 | return predicate.build() + " (" + StringUtils.join(",", columns) + ")"; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/insert/InsertIntoBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder.insert; 2 | 3 | import com.alexfu.sqlitequerybuilder.builder.SegmentBuilder; 4 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 5 | 6 | import static com.alexfu.sqlitequerybuilder.utils.Preconditions.checkArgument; 7 | 8 | public class InsertIntoBuilder extends SegmentBuilder { 9 | private final InsertBuilder predicate; 10 | private final String table; 11 | 12 | public InsertIntoBuilder(InsertBuilder predicate, String table) { 13 | this.predicate = predicate; 14 | this.table = table; 15 | } 16 | 17 | public InsertColumnsBuilder columns(String...columns) { 18 | checkArgument(columns != null, "Column names cannot be null"); 19 | return new InsertColumnsBuilder(this, columns); 20 | } 21 | 22 | @Override 23 | public String build() { 24 | return StringUtils.join(" ", predicate.build(), table); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/builder/insert/InsertValuesBuilder.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.builder.insert; 2 | 3 | import com.alexfu.sqlitequerybuilder.builder.SegmentBuilder; 4 | import com.alexfu.sqlitequerybuilder.utils.DateUtils; 5 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 6 | 7 | import java.util.Calendar; 8 | 9 | public class InsertValuesBuilder extends SegmentBuilder { 10 | private final SegmentBuilder predicate; 11 | private final Object[] values; 12 | 13 | public InsertValuesBuilder(SegmentBuilder predicate, Object[] values) { 14 | this.predicate = predicate; 15 | this.values = clean(values); 16 | } 17 | 18 | private Object[] clean(Object[] values) { 19 | Object[] clean = new Object[values.length]; 20 | for (int i = 0; i < values.length; i++) { 21 | Object item = values[i]; 22 | 23 | if (item instanceof String) { 24 | item = "'" + item + "'"; 25 | } 26 | 27 | if (item instanceof Calendar) { 28 | Calendar date = (Calendar) item; 29 | item = "'" + DateUtils.iso8601().format(date.getTime()) + "'"; 30 | } 31 | 32 | clean[i] = item; 33 | } 34 | return clean; 35 | } 36 | 37 | @Override 38 | public String build() { 39 | return predicate.build() + " values (" + StringUtils.join(",", values) + ")"; 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/utils/DateUtils.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.utils; 2 | 3 | import java.text.DateFormat; 4 | import java.text.SimpleDateFormat; 5 | 6 | public class DateUtils { 7 | private static DateFormat ISO8601; 8 | 9 | public static DateFormat iso8601() { 10 | if (ISO8601 == null) { 11 | ISO8601 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mmZ"); 12 | } 13 | return ISO8601; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/utils/Preconditions.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2007 The Guava Authors 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except 5 | * in compliance with the License. You may obtain a copy of the License at 6 | * 7 | * http://www.apache.org/licenses/LICENSE-2.0 8 | * 9 | * Unless required by applicable law or agreed to in writing, software distributed under the License 10 | * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express 11 | * or implied. See the License for the specific language governing permissions and limitations under 12 | * the License. 13 | */ 14 | 15 | package com.alexfu.sqlitequerybuilder.utils; 16 | 17 | public final class Preconditions { 18 | private Preconditions() { 19 | // No op 20 | } 21 | 22 | /** 23 | * Ensures that an object reference passed as a parameter to the calling method is not null. 24 | * 25 | * @param reference an object reference 26 | * @return the non-null reference that was validated 27 | * @throws NullPointerException if {@code reference} is null 28 | */ 29 | public static T checkNotNull(T reference) { 30 | if (reference == null) { 31 | throw new NullPointerException(); 32 | } 33 | 34 | return reference; 35 | } 36 | 37 | /** 38 | * Ensures that an object reference passed as a parameter to the calling method is not null. 39 | * 40 | * @param reference an object reference 41 | * @param message exception message 42 | * @return the non-null reference that was validated 43 | * @throws NullPointerException if {@code reference} is null 44 | */ 45 | public static T checkNotNull(T reference, String message) { 46 | if (reference == null) { 47 | throw new NullPointerException(message); 48 | } 49 | 50 | return reference; 51 | } 52 | 53 | /** 54 | * Ensures the truth of an expression involving one or more parameters to the 55 | * calling method. 56 | * 57 | * @param expression a boolean expression 58 | * @param errorMessage the exception message to use if the check fails 59 | * @throws IllegalArgumentException if {@code expression} is false 60 | */ 61 | public static void checkArgument( 62 | boolean expression, String errorMessage) { 63 | if (!expression) { 64 | throw new IllegalArgumentException(String.valueOf(errorMessage)); 65 | } 66 | } 67 | 68 | public static String checkNotEmpty(String name, String message) { 69 | checkNotNull(name, message); 70 | if (name.isEmpty()) { 71 | throw new IllegalArgumentException(message); 72 | } 73 | return name; 74 | } 75 | } 76 | -------------------------------------------------------------------------------- /src/main/java/com/alexfu/sqlitequerybuilder/utils/StringUtils.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder.utils; 2 | 3 | public class StringUtils { 4 | public static String join(CharSequence delimiter, String... array) { 5 | return join(delimiter, (Object[]) array); 6 | } 7 | 8 | public static String join(CharSequence delimiter, Object... array) { 9 | StringBuilder sb = new StringBuilder(); 10 | 11 | for (int i = 0, size = array.length; i < size; i++) { 12 | if (i > 0) { 13 | sb.append(delimiter); 14 | } 15 | sb.append(array[i]); 16 | } 17 | return sb.toString(); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/test/java/com/alexfu/sqlitequerybuilder/CreateTableTest.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder; 2 | 3 | import static org.assertj.core.api.Assertions.assertThat; 4 | 5 | import org.junit.Test; 6 | 7 | import com.alexfu.sqlitequerybuilder.api.Column; 8 | import com.alexfu.sqlitequerybuilder.api.ColumnConstraint; 9 | import com.alexfu.sqlitequerybuilder.api.ColumnType; 10 | import com.alexfu.sqlitequerybuilder.api.SQLiteQueryBuilder; 11 | 12 | public class CreateTableTest { 13 | 14 | @Test 15 | public final void testCreateTableWithOneColumn() { 16 | // Arrange 17 | Column column = new Column("column1", ColumnType.INTEGER, ColumnConstraint.PRIMARY_KEY); 18 | 19 | // Act 20 | String query = SQLiteQueryBuilder 21 | .create() 22 | .table("myTable") 23 | .column(column) 24 | .toString(); 25 | 26 | // Assert 27 | assertThat(query).isEqualTo("CREATE TABLE myTable(column1 INTEGER PRIMARY KEY)"); 28 | } 29 | 30 | @Test 31 | public final void testCreateTableWithMultipleColumns() { 32 | // Arrange 33 | Column column1 = new Column("column1", ColumnType.INTEGER, ColumnConstraint.PRIMARY_KEY); 34 | Column column2 = new Column("column2", ColumnType.TEXT); 35 | Column column3 = new Column("column3", ColumnType.TEXT, ColumnConstraint.NOT_NULL); 36 | 37 | // Act 38 | String query = SQLiteQueryBuilder 39 | .create() 40 | .table("myTable") 41 | .column(column1) 42 | .column(column2) 43 | .column(column3) 44 | .toString(); 45 | 46 | // Assert 47 | assertThat(query).isEqualTo("CREATE TABLE myTable(column1 INTEGER PRIMARY KEY,column2 TEXT," 48 | + "column3 TEXT NOT NULL)"); 49 | } 50 | 51 | @Test 52 | public final void testCreateTableWithDefaultColumnValue() { 53 | // Arrange 54 | Column column = new Column("column1", ColumnType.INTEGER, ColumnConstraint.PRIMARY_KEY, "0"); 55 | 56 | // Act 57 | String query = SQLiteQueryBuilder 58 | .create() 59 | .table("myTable") 60 | .column(column) 61 | .toString(); 62 | 63 | // Assert 64 | assertThat(query).isEqualTo("CREATE TABLE myTable(column1 INTEGER PRIMARY KEY DEFAULT 0)"); 65 | } 66 | 67 | @Test(expected = IllegalArgumentException.class) 68 | public final void passNullColumnShouldThrowExeption() { 69 | // Act 70 | SQLiteQueryBuilder 71 | .create() 72 | .table("myTable") 73 | .column(null) 74 | .toString(); 75 | } 76 | 77 | @Test 78 | public final void createTableIfNotExists() { 79 | // Arrange 80 | Column column = new Column("column1", ColumnType.INTEGER, ColumnConstraint.PRIMARY_KEY); 81 | 82 | // Act 83 | String query = SQLiteQueryBuilder 84 | .create() 85 | .table("myTable") 86 | .ifNotExists() 87 | .column(column) 88 | .toString(); 89 | 90 | // Assert 91 | assertThat(query).isEqualTo("CREATE TABLE IF NOT EXISTS myTable(column1 INTEGER PRIMARY KEY)"); 92 | } 93 | 94 | @Test 95 | public final void createTempTable() { 96 | Column column = new Column("column1", ColumnType.INTEGER, ColumnConstraint.PRIMARY_KEY); 97 | 98 | String query = SQLiteQueryBuilder 99 | .create() 100 | .temp() 101 | .table("myTable") 102 | .column(column) 103 | .build(); 104 | 105 | assertThat(query).isEqualTo("CREATE TEMP TABLE myTable(column1 INTEGER PRIMARY KEY)"); 106 | } 107 | 108 | @Test 109 | public final void createTempTableIfNotExists() { 110 | Column column = new Column("column1", ColumnType.INTEGER, ColumnConstraint.PRIMARY_KEY); 111 | 112 | String query = SQLiteQueryBuilder 113 | .create() 114 | .temp() 115 | .table("myTable") 116 | .ifNotExists() 117 | .column(column) 118 | .build(); 119 | 120 | assertThat(query).isEqualTo("CREATE TEMP TABLE IF NOT EXISTS myTable(column1 INTEGER " 121 | + "PRIMARY KEY)"); 122 | } 123 | 124 | @Test(expected = IllegalArgumentException.class) 125 | public final void emptyTableName() { 126 | Column column = new Column("column1", ColumnType.INTEGER, ColumnConstraint.PRIMARY_KEY); 127 | 128 | SQLiteQueryBuilder 129 | .create() 130 | .table("") 131 | .column(column) 132 | .build(); 133 | } 134 | 135 | @Test 136 | public final void createTablePrimaryKeyAutoIncrement() { 137 | Column column = new Column("column1", ColumnType.INTEGER, 138 | ColumnConstraint.PRIMARY_KEY_AUTO_INCREMENT); 139 | 140 | String query = SQLiteQueryBuilder 141 | .create() 142 | .table("myTable") 143 | .column(column) 144 | .build(); 145 | 146 | assertThat(query).isEqualTo("CREATE TABLE myTable(column1 INTEGER PRIMARY KEY AUTOINCREMENT)"); 147 | } 148 | 149 | } 150 | -------------------------------------------------------------------------------- /src/test/java/com/alexfu/sqlitequerybuilder/DeleteTest.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder; 2 | 3 | import com.alexfu.sqlitequerybuilder.api.SQLiteQueryBuilder; 4 | import org.junit.Test; 5 | 6 | import static org.assertj.core.api.Assertions.assertThat; 7 | 8 | /** 9 | * Created by alexfu on 7/7/15. 10 | */ 11 | public class DeleteTest { 12 | @Test 13 | public void testDeleteAll() { 14 | String sql = SQLiteQueryBuilder 15 | .delete() 16 | .from("my_table") 17 | .build(); 18 | 19 | assertThat(sql).isEqualTo("DELETE FROM my_table"); 20 | } 21 | 22 | @Test 23 | public void testDeleteWhere() { 24 | String sql = SQLiteQueryBuilder 25 | .delete() 26 | .from("my_table") 27 | .where("id = 1") 28 | .build(); 29 | 30 | assertThat(sql).isEqualTo("DELETE FROM my_table WHERE id = 1"); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/test/java/com/alexfu/sqlitequerybuilder/DropTest.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder; 2 | 3 | import org.junit.Test; 4 | 5 | import static org.assertj.core.api.Assertions.assertThat; 6 | 7 | import com.alexfu.sqlitequerybuilder.api.SQLiteQueryBuilder; 8 | 9 | public class DropTest { 10 | 11 | @Test 12 | public final void testDropTable() { 13 | // Arrange and Act 14 | String statement = SQLiteQueryBuilder 15 | .drop() 16 | .table("myTable") 17 | .ifExists() 18 | .toString(); 19 | 20 | // Assert 21 | assertThat(statement).isEqualTo("DROP TABLE IF EXISTS myTable"); 22 | } 23 | 24 | @Test 25 | public final void testDropTableNoIfExists() { 26 | // Arrange and Act 27 | String statement = SQLiteQueryBuilder 28 | .drop() 29 | .table("myTable") 30 | .toString(); 31 | 32 | // Assert 33 | assertThat(statement).isEqualTo("DROP TABLE myTable"); 34 | } 35 | 36 | @Test 37 | public final void testDropView() { 38 | // Arrange and Act 39 | String statement = SQLiteQueryBuilder 40 | .drop() 41 | .view("myView") 42 | .ifExists() 43 | .toString(); 44 | 45 | // Assert 46 | assertThat(statement).isEqualTo("DROP VIEW IF EXISTS myView"); 47 | } 48 | 49 | @Test 50 | public final void testDropViewNoIfExists() { 51 | // Arrange and Act 52 | String statement = SQLiteQueryBuilder 53 | .drop() 54 | .view("myView") 55 | .toString(); 56 | 57 | // Assert 58 | assertThat(statement).isEqualTo("DROP VIEW myView"); 59 | } 60 | 61 | @Test 62 | public final void testDropIndex() { 63 | // Arrange and Act 64 | String statement = SQLiteQueryBuilder 65 | .drop() 66 | .index("myIndex") 67 | .ifExists() 68 | .toString(); 69 | 70 | // Assert 71 | assertThat(statement).isEqualTo("DROP INDEX IF EXISTS myIndex"); 72 | } 73 | 74 | @Test 75 | public final void testDropIndexNoIfExists() { 76 | // Arrange and Act 77 | String statement = SQLiteQueryBuilder 78 | .drop() 79 | .index("myIndex") 80 | .toString(); 81 | 82 | // Assert 83 | assertThat(statement).isEqualTo("DROP INDEX myIndex"); 84 | } 85 | 86 | @Test 87 | public final void testDropTrigger() { 88 | // Arrange and Act 89 | String statement = SQLiteQueryBuilder 90 | .drop() 91 | .trigger("myTrigger") 92 | .ifExists() 93 | .toString(); 94 | 95 | // Assert 96 | assertThat(statement).isEqualTo("DROP TRIGGER IF EXISTS myTrigger"); 97 | } 98 | 99 | @Test 100 | public final void testDropTriggerNoIfExists() { 101 | // Arrange and Act 102 | String statement = SQLiteQueryBuilder 103 | .drop() 104 | .trigger("myTrigger") 105 | .toString(); 106 | 107 | // Assert 108 | assertThat(statement).isEqualTo("DROP TRIGGER myTrigger"); 109 | } 110 | } 111 | -------------------------------------------------------------------------------- /src/test/java/com/alexfu/sqlitequerybuilder/InsertTest.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder; 2 | 3 | import com.alexfu.sqlitequerybuilder.api.SQLiteQueryBuilder; 4 | import com.alexfu.sqlitequerybuilder.utils.DateUtils; 5 | import org.junit.Test; 6 | 7 | import java.util.Calendar; 8 | 9 | import static org.assertj.core.api.Assertions.assertThat; 10 | 11 | public class InsertTest { 12 | @Test 13 | public void insertWithGoodValues() { 14 | Calendar timestamp = Calendar.getInstance(); 15 | String sql = SQLiteQueryBuilder.insert() 16 | .into("people") 17 | .columns("id", "name", "timestamp") 18 | .values(1, "John", Calendar.getInstance()) 19 | .build(); 20 | 21 | String iso8601 = DateUtils.iso8601().format(timestamp.getTime()); 22 | String result = "INSERT INTO people (id,name,timestamp) values (1,'John','" + iso8601 + "')"; 23 | assertThat(sql).isEqualTo(result); 24 | } 25 | 26 | @Test(expected = IllegalArgumentException.class) 27 | public void insertWithNullColumns() { 28 | SQLiteQueryBuilder.insert() 29 | .into("people") 30 | .columns(null) 31 | .values(1, "John", Calendar.getInstance()) 32 | .build(); 33 | } 34 | 35 | @Test(expected = IllegalArgumentException.class) 36 | public void insertWithNullValues() { 37 | SQLiteQueryBuilder.insert() 38 | .into("people") 39 | .columns("id", "name", "timestamp") 40 | .values(null) 41 | .build(); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/test/java/com/alexfu/sqlitequerybuilder/SelectTest.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder; 2 | 3 | import com.alexfu.sqlitequerybuilder.api.SQLiteQueryBuilder; 4 | import com.alexfu.sqlitequerybuilder.api.SelectType; 5 | import org.junit.Test; 6 | 7 | import static org.assertj.core.api.Assertions.assertThat; 8 | 9 | public class SelectTest { 10 | @Test 11 | public void singleColumnSelectTest() { 12 | String query = SQLiteQueryBuilder 13 | .select("column") 14 | .from("mytable") 15 | .build(); 16 | 17 | assertThat(query).isEqualTo("SELECT column FROM mytable"); 18 | } 19 | 20 | @Test 21 | public void multiColumnSelectTest() { 22 | String query = SQLiteQueryBuilder. 23 | select("column1", "column2", "column3") 24 | .from("mytable") 25 | .build(); 26 | 27 | assertThat(query).isEqualTo("SELECT column1,column2,column3 FROM mytable"); 28 | } 29 | 30 | @Test 31 | public void starColumnSelectTest() { 32 | String query = SQLiteQueryBuilder 33 | .select("*") 34 | .from("mytable") 35 | .build(); 36 | 37 | assertThat(query).isEqualTo("SELECT * FROM mytable"); 38 | } 39 | 40 | @Test 41 | public void selectWhereTest() { 42 | String query = SQLiteQueryBuilder 43 | .select("column") 44 | .from("mytable") 45 | .where("id = 1") 46 | .build(); 47 | 48 | assertThat(query).isEqualTo("SELECT column FROM mytable WHERE id = 1"); 49 | } 50 | 51 | @Test 52 | public void selectJoinTest() { 53 | String query = SQLiteQueryBuilder 54 | .select("*") 55 | .from("mytable") 56 | .join("secondtable") 57 | .on("mytable.id = secondtable.id") 58 | .where("id = 1") 59 | .build(); 60 | 61 | assertThat(query).isEqualTo("SELECT * FROM mytable JOIN secondtable ON " 62 | + "mytable.id = secondtable.id " 63 | + "WHERE id = 1"); 64 | } 65 | 66 | @Test 67 | public void selectLeftOuterJoinTest() { 68 | String query = SQLiteQueryBuilder 69 | .select("*") 70 | .from("mytable") 71 | .leftOuterJoin("secondtable") 72 | .on("mytable.id = secondtable.id") 73 | .where("id = 1") 74 | .build(); 75 | 76 | assertThat(query).isEqualTo("SELECT * FROM mytable LEFT OUTER JOIN secondtable ON " 77 | + "mytable.id = secondtable.id WHERE id = 1"); 78 | } 79 | 80 | @Test 81 | public void selectCrossJoinTest() { 82 | String query = SQLiteQueryBuilder 83 | .select("*") 84 | .from("mytable") 85 | .crossJoin("secondtable") 86 | .build(); 87 | 88 | assertThat(query).isEqualTo("SELECT * FROM mytable CROSS JOIN secondtable"); 89 | } 90 | 91 | @Test 92 | public void selectNaturalJoinTest() { 93 | String query = SQLiteQueryBuilder 94 | .select("*") 95 | .from("mytable") 96 | .naturalJoin("secondtable") 97 | .build(); 98 | 99 | assertThat(query).isEqualTo("SELECT * FROM mytable NATURAL JOIN secondtable"); 100 | } 101 | 102 | @Test 103 | public void selectNaturalLeftOuterJoinTest() { 104 | String query = SQLiteQueryBuilder 105 | .select("*") 106 | .from("mytable") 107 | .naturalLeftOuterJoin("secondtable") 108 | .build(); 109 | 110 | assertThat(query).isEqualTo("SELECT * FROM mytable NATURAL LEFT OUTER JOIN secondtable"); 111 | } 112 | 113 | @Test 114 | public void selectMultiJoinTest() { 115 | String query = SQLiteQueryBuilder 116 | .select("*") 117 | .from("mytable") 118 | .join("secondtable") 119 | .on("mytable.id = secondtable.id") 120 | .join("thirdtable") 121 | .on("secondtable.id = thirdtable.id") 122 | .where("id = 1") 123 | .build(); 124 | 125 | assertThat(query).isEqualTo("SELECT * FROM mytable JOIN secondtable ON " 126 | + "mytable.id = secondtable.id " 127 | + "JOIN thirdtable ON secondtable.id = thirdtable.id WHERE id = 1"); 128 | } 129 | 130 | @Test 131 | public void selectAndTest() { 132 | String query = SQLiteQueryBuilder 133 | .select("*") 134 | .from("mytable") 135 | .where("id = 1") 136 | .and("color = 'red'") 137 | .build(); 138 | 139 | assertThat(query).isEqualTo("SELECT * FROM mytable WHERE id = 1 AND color = 'red'"); 140 | } 141 | 142 | @Test 143 | public void selectAndAndTest() { 144 | String query = SQLiteQueryBuilder 145 | .select("*") 146 | .from("mytable") 147 | .where("id = 1") 148 | .and("color = 'red'") 149 | .and("color = 'blue'") 150 | .build(); 151 | 152 | assertThat(query).isEqualTo("SELECT * FROM mytable WHERE id = 1 AND color = 'red' " + 153 | "AND color = 'blue'"); 154 | } 155 | 156 | @Test 157 | public void selectWhereLimitTest() { 158 | String query = SQLiteQueryBuilder 159 | .select("*") 160 | .from("mytable") 161 | .where("id = 1") 162 | .limit(5) 163 | .build(); 164 | 165 | assertThat(query).isEqualTo("SELECT * FROM mytable WHERE id = 1 LIMIT 5"); 166 | } 167 | 168 | @Test 169 | public void selectLimitTest() { 170 | String query = SQLiteQueryBuilder 171 | .select("*") 172 | .from("mytable") 173 | .limit(5) 174 | .build(); 175 | 176 | assertThat(query).isEqualTo("SELECT * FROM mytable LIMIT 5"); 177 | } 178 | 179 | @Test 180 | public void selectOrderByTest() { 181 | String query = SQLiteQueryBuilder 182 | .select("*") 183 | .from("mytable") 184 | .orderBy("rank") 185 | .build(); 186 | 187 | assertThat(query).isEqualTo("SELECT * FROM mytable ORDER BY rank"); 188 | } 189 | 190 | @Test 191 | public void selectGroupByTest() { 192 | String query = SQLiteQueryBuilder 193 | .select("*") 194 | .from("mytable") 195 | .groupBy("rank") 196 | .build(); 197 | 198 | assertThat(query).isEqualTo("SELECT * FROM mytable GROUP BY rank"); 199 | } 200 | 201 | @Test 202 | public void selectGroupByHavingOrderTest() { 203 | String query = SQLiteQueryBuilder 204 | .select("*") 205 | .from("mytable") 206 | .groupBy("rank") 207 | .having("age > 0") 208 | .orderBy("rank") 209 | .build(); 210 | 211 | assertThat(query).isEqualTo("SELECT * FROM mytable GROUP BY rank HAVING age > 0 ORDER BY rank"); 212 | } 213 | 214 | @Test 215 | public void selectGroupByHavingLimitTest() { 216 | String query = SQLiteQueryBuilder 217 | .select("*") 218 | .from("mytable") 219 | .groupBy("rank") 220 | .having("age > 0") 221 | .limit(3) 222 | .build(); 223 | 224 | assertThat(query).isEqualTo("SELECT * FROM mytable GROUP BY rank HAVING age > 0 LIMIT 3"); 225 | } 226 | 227 | @Test 228 | public void selectOrderByAdvancedTest() { 229 | String query = SQLiteQueryBuilder 230 | .select("*") 231 | .from("mytable") 232 | .where("id = 1") 233 | .orderBy("rank") 234 | .desc() 235 | .limit(10) 236 | .offset(5) 237 | .build(); 238 | 239 | assertThat(query).isEqualTo("SELECT * FROM mytable WHERE id = 1 ORDER BY rank DESC LIMIT 10 " 240 | + "OFFSET 5"); 241 | } 242 | 243 | @Test 244 | public void selectDistinctTest() { 245 | String query = SQLiteQueryBuilder 246 | .select(SelectType.DISTINCT("one", "two", "three")) 247 | .from("mytable") 248 | .build(); 249 | 250 | assertThat(query).isEqualTo("SELECT DISTINCT one,two,three FROM mytable"); 251 | } 252 | 253 | @Test 254 | public void selectAllTest() { 255 | String query = SQLiteQueryBuilder 256 | .select(SelectType.ALL("one", "two", "three")) 257 | .from("mytable") 258 | .build(); 259 | 260 | assertThat(query).isEqualTo("SELECT ALL one,two,three FROM mytable"); 261 | } 262 | 263 | @Test 264 | public void selectOrderByAsc() { 265 | String query = SQLiteQueryBuilder 266 | .select("*") 267 | .from("mytable") 268 | .orderBy("age") 269 | .asc() 270 | .build(); 271 | 272 | assertThat(query).isEqualTo("SELECT * FROM mytable ORDER BY age ASC"); 273 | } 274 | 275 | @Test(expected = IllegalArgumentException.class) 276 | public void testNullArgs() { 277 | SQLiteQueryBuilder 278 | .select("*") 279 | .from(null) 280 | .build(); 281 | } 282 | } 283 | -------------------------------------------------------------------------------- /src/test/java/com/alexfu/sqlitequerybuilder/StringUtilsTest.java: -------------------------------------------------------------------------------- 1 | package com.alexfu.sqlitequerybuilder; 2 | 3 | import com.alexfu.sqlitequerybuilder.utils.StringUtils; 4 | import org.junit.Test; 5 | 6 | import static org.junit.Assert.assertEquals; 7 | 8 | public class StringUtilsTest { 9 | @Test 10 | public void joinsStringsWithCommaDelimeter() { 11 | String[] strings = {"One", "Two", "Three", "Four", "Five"}; 12 | 13 | String expected = "One,Two,Three,Four,Five"; 14 | String result = StringUtils.join(",", strings); 15 | assertEquals(expected, result); 16 | } 17 | } 18 | --------------------------------------------------------------------------------