Repository: x2bool/kuery
Branch: master
Commit: 18671cd841c3
Files: 38
Total size: 94.0 KB
Directory structure:
gitextract_cz49ip86/
├── .gitignore
├── LICENSE
├── README.md
├── bintray.gradle
├── build.gradle
├── core/
│ ├── build.gradle
│ └── src/
│ └── tel/
│ └── egram/
│ └── kuery/
│ ├── Dialect.kt
│ ├── Predicate.kt
│ ├── Subject.kt
│ ├── Table.kt
│ ├── ddl/
│ │ ├── CreateTableStatement.kt
│ │ ├── Definition.kt
│ │ └── DropTableStatement.kt
│ └── dml/
│ ├── Assignment.kt
│ ├── DeleteStatement.kt
│ ├── GroupClause.kt
│ ├── HavingClause.kt
│ ├── InsertStatement.kt
│ ├── JoinClause.kt
│ ├── LimitClause.kt
│ ├── OffsetClause.kt
│ ├── OrderClause.kt
│ ├── Ordering.kt
│ ├── Projection.kt
│ ├── SelectStatement.kt
│ ├── UpdateStatement.kt
│ └── WhereClause.kt
├── gradle/
│ └── wrapper/
│ ├── gradle-wrapper.jar
│ └── gradle-wrapper.properties
├── gradle.properties
├── gradlew
├── gradlew.bat
├── sample-maven.properties
├── settings.gradle
└── sqlite/
├── build.gradle
├── src/
│ └── tel/
│ └── egram/
│ └── kuery/
│ └── sqlite/
│ ├── SQLiteDefinition.kt
│ └── SQLiteDialect.kt
└── test/
└── tel/
└── egram/
└── kuery/
└── sqlite/
└── tests/
└── SQLiteDialectTest.kt
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
build/
.gradle/
.idea/
*.iml
maven.properties
local.properties
.DS_Store
out
================================================
FILE: LICENSE
================================================
The MIT License (MIT)
Copyright (c) 2016 Sergey Khabibullin
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
================================================
FILE: README.md
================================================
# Kuery - strongly typed SQL in Kotlin
The library is a strongly typed alternative to plain text SQL. The main goal of this project is to make database-related code easier to develop and maintain. The project uses some of the Kotlin language features to achieve type safety.
## Features
* SQL-like syntax. Use language constructions you already know. Designed to cover the most common SQL features.
* Strongly typed DSL makes it harder to make mistakes. Some of the most common errors are catched at compile time.
* IDE's assist in code editing.
* Easier and safer refactoring/renaming.
* No reflection
## Foundation
Database structure is defined by classes/objects inherited from the **Table** class. Tables are **not** domain model classes. Their purpose is to simply define relationships between tables and columns.
```kotlin
import tel.egram.kuery.*
object Organizations : Table("organizations") {
val id = Column("id")
val name = Column("name")
}
object Employees : Table("employees") {
val id = Column("id")
val name = Column("name")
val organizationId = Column("organization_id")
}
```
**Statements** are the building blocks of the library. A statement usually starts with one of the following function calls:
* over(table) - used for **CREATE TABLE** and **DROP TABLE** statements
* into(table) - used for **INSERT** statements
* from(table) - used for **SELECT**, **UPDATE** and **DELETE** statements
**Dialects** are responsible for converting statements into actual SQL:
```kotlin
import tel.egram.kuery.*
import tel.egram.kuery.sqlite.*
val statement = from(Employees).where { e -> e.id eq 1 }.select { e -> e.name }
val sql = statement.toString(SQLiteDialect)
print(sql) // SELECT "name" FROM "employees" WHERE "id" = 1
```
## Data Definition Language
Some parts of data definition language are specific to SQL dialects. An example for SQLite might look like this:
### CREATE TABLE statement
```kotlin
import tel.egram.kuery.*
import tel.egram.kuery.sqlite.*
// CREATE TABLE "organizations" ...
over(Organizations)
.create {
integer(it.id).primaryKey(autoIncrement = true)..
text(it.name).unique().notNull()
}
// CREATE TABLE "employees" ...
over(Employees)
.create {
integer(it.id).primaryKey(autoIncrement = true)..
text(it.name).unique().notNull()..
integer(it.organizationId).foreignKey(references = Organizations.id)
}
```
### DROP TABLE statement
```kotlin
// DROP TABLE "employees"
over(Employees).drop()
```
## Data Manipulation Language
Data manipulation is the most powerfull and complex part of SQL. The library supports **INSERT**, **SELECT**, **UPDATE** and **DELETE** statements.
### INSERT statement
```kotlin
// INSERT INTO "employees"("name", "organization_id") VALUES("John Doe", 1)
into(Employees)
.insert { e -> e.name("John Doe") .. e.organizationId(1) }
```
### SELECT statement
The library provides the following operators to compose queries:
* and
* or
* not
* eq (equals)
* ne (not equals)
* lt (less than)
* lte (less than or equal to)
* gt (greater than)
* gte (greater than or equal to)
```kotlin
// SELECT "id", "name" FROM "organizations" WHERE ...
from(Employees)
.where { e -> (e.organizationId ne null) and (e.name eq "John Doe") }
.groupBy { e -> e.name }
.having { e -> e.id ne null }
.orderBy { e -> e.name.asc .. e.id.desc }
.limit { 10 }
.offset { 10 }
.select { e -> e.id .. e.name }
```
**JOINs** are also supported in select statements
```kotlin
// SELECT ... FROM "organizations" JOIN "employees" ON ...
from(Organizations)
.join(Employees).on { o, e -> o.id eq e.organizationId }
.select { o, e -> o.name .. e.name }
```
### UPDATE statement
```kotlin
// UPDATE "organizations" SET "name" = 'John Doe' WHERE "id" = 1
from(Organizations)
.where { o -> o.id eq 1 }
.update { o -> o.name("John Doe") }
```
### DELETE statement
```kotlin
// DELETE FROM "organizations" WHERE "id" = 0
from(Organizations)
.where { o -> o.id eq 0 }
.delete()
```
## Download
Maven:
```xml
<!-- Core library -->
<dependency>
<groupId>tel.egram.kuery</groupId>
<artifactId>core</artifactId>
<version>0.5.3</version>
<type>pom</type>
</dependency>
<!-- SQLite dialect -->
<dependency>
<groupId>tel.egram.kuery</groupId>
<artifactId>sqlite</artifactId>
<version>0.5.3</version>
<type>pom</type>
</dependency>
```
Gradle:
```groovy
// Core library
compile 'tel.egram.kuery:core:0.5.3'
// SQLite dialect
compile 'tel.egram.kuery:sqlite:0.5.3'
```
================================================
FILE: bintray.gradle
================================================
apply plugin: 'maven-publish'
apply plugin: 'com.jfrog.bintray'
defaultTasks 'jar'
task sourcesJar(type: Jar, dependsOn: project.classes) {
from sourceSets.main.allSource
}
task javadocJar(type: Jar, dependsOn: project.javadoc) {
from javadoc.destinationDir
}
artifacts {
archives sourcesJar, javadocJar
}
def projDescription = 'Strongly typed alternative to plain text SQL. Powered by Kotlin.'
project.ext.set("bintray_repo", "")
if (file("${rootProject.projectDir}/maven.properties").exists()) {
Properties properties = new Properties()
properties.load(new FileInputStream("${rootProject.projectDir}/maven.properties"))
properties.each { prop ->
project.ext.set(prop.key, prop.value)
}
}
publishing {
publications {
"${project.name}"(MavenPublication) {
pom.withXml {
asNode().appendNode('description', projDescription)
}
groupId rootProject.group_id
artifactId project.name
version rootProject.ext.version_name
artifact sourcesJar { classifier = 'sources' }
artifact javadocJar { classifier = 'javadoc' }
from components.java
}
}
repositories {
maven {
url "$bintray_repo"
}
maven {
url "https://jitpack.io"
}
}
}
bintray {
user = project.ext.properties.containsKey("bintray_user") ? project.ext.get("bintray_user") : System.getenv('BINTRAY_USER')
key = project.ext.properties.containsKey("bintray_apikey") ? project.ext.get("bintray_apikey") : System.getenv('BINTRAY_API_KEY')
publications = [project.name]
pkg {
repo = 'maven'
name = 'kuery'
userOrg = 'egram'
licenses = ['MIT']
vcsUrl = 'https://github.com/x2bool/kuery.git'
publish = true
publicDownloadNumbers = true
version {
name = rootProject.ext.version_name
desc = projDescription
released = new Date()
vcsTag = rootProject.ext.version_name
}
}
}
bintrayUpload.dependsOn "generatePomFileFor${project.name.capitalize()}Publication"
================================================
FILE: build.gradle
================================================
buildscript {
ext.kotlin_version = '1.2.41'
repositories {
jcenter()
mavenCentral()
}
dependencies {
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:1+"
}
}
ext.group_id = 'tel.egram.kuery'
ext.version_name = '0.5.3'
allprojects {
apply plugin: 'maven'
repositories {
jcenter()
mavenCentral()
}
}
================================================
FILE: core/build.gradle
================================================
apply plugin: 'kotlin'
apply from: "${rootProject.rootDir}/bintray.gradle"
sourceSets {
main.kotlin.srcDirs += 'src'
}
dependencies {
compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
}
================================================
FILE: core/src/tel/egram/kuery/Dialect.kt
================================================
package tel.egram.kuery
import tel.egram.kuery.ddl.*
import tel.egram.kuery.dml.*
interface Dialect {
fun <T: Table> build(statement: CreateTableStatement<T>): String
fun <T: Table> build(statement: DropTableStatement<T>): String
fun <T: Table> build(statement: SelectStatement<T>): String
fun <T: Table, T2: Table> build(statement: Select2Statement<T, T2>): String
fun <T: Table, T2: Table, T3: Table> build(statement: Select3Statement<T, T2, T3>): String
fun <T: Table, T2: Table, T3: Table, T4: Table> build(statement: Select4Statement<T, T2, T3, T4>): String
fun <T: Table> build(statement: InsertStatement<T>): String
fun <T: Table> build(statement: UpdateStatement<T>): String
fun <T: Table> build(statement: DeleteStatement<T>): String
}
================================================
FILE: core/src/tel/egram/kuery/Predicate.kt
================================================
package tel.egram.kuery
interface Predicate
/**
* Not expression
*/
class NotExpression(val param: Any?) : Predicate
fun not(predicate: Predicate): NotExpression {
return NotExpression(predicate)
}
/**
* And expression
*/
class AndExpression(val left: Any?, val right: Any?) : Predicate
infix fun Predicate.and(predicate: Predicate): AndExpression {
return AndExpression(this, predicate)
}
/**
* Or expression
*/
class OrExpression(val left: Any?, val right: Any?) : Predicate
infix fun Predicate.or(predicate: Predicate): OrExpression {
return OrExpression(this, predicate)
}
/**
* Equals expression
*/
class EqExpression(val left: Any?, val right: Any?) : Predicate
infix fun Table.Column.eq(column: Table.Column): EqExpression {
return EqExpression(this, column)
}
infix fun Table.Column.eq(str: String?): EqExpression {
return EqExpression(this, str)
}
infix fun Table.Column.eq(num: Number): EqExpression {
return EqExpression(this, num)
}
infix fun Table.Column.eq(flag: Boolean): EqExpression {
return EqExpression(this, flag)
}
/**
* Not equals expression
*/
class NeExpression(val left: Any?, val right: Any?) : Predicate
infix fun Table.Column.ne(column: Table.Column): NeExpression {
return NeExpression(this, column)
}
infix fun Table.Column.ne(str: String?): NeExpression {
return NeExpression(this, str)
}
infix fun Table.Column.ne(num: Number): NeExpression {
return NeExpression(this, num)
}
infix fun Table.Column.ne(flag: Boolean): NeExpression {
return NeExpression(this, flag)
}
/**
* Less than expression
*/
class LtExpression(val left: Any?, val right: Any?) : Predicate
infix fun Table.Column.lt(column: Table.Column): LtExpression {
return LtExpression(this, column)
}
infix fun Table.Column.lt(str: String?): LtExpression {
return LtExpression(this, str)
}
infix fun Table.Column.lt(num: Number): LtExpression {
return LtExpression(this, num)
}
/**
* Less than or equal expression
*/
class LteExpression(val left: Any?, val right: Any?) : Predicate
infix fun Table.Column.lte(column: Table.Column): LteExpression {
return LteExpression(this, column)
}
infix fun Table.Column.lte(str: String?): LteExpression {
return LteExpression(this, str)
}
infix fun Table.Column.lte(num: Number): LteExpression {
return LteExpression(this, num)
}
/**
* Greater than expression
*/
class GtExpression(val left: Any?, val right: Any?) : Predicate
infix fun Table.Column.gt(column: Table.Column): GtExpression {
return GtExpression(this, column)
}
infix fun Table.Column.gt(str: String?): GtExpression {
return GtExpression(this, str)
}
infix fun Table.Column.gt(num: Number): GtExpression {
return GtExpression(this, num)
}
/**
* Greater than or equal expression
*/
class GteExpression(val left: Any?, val right: Any?) : Predicate
infix fun Table.Column.gte(column: Table.Column): GteExpression {
return GteExpression(this, column)
}
infix fun Table.Column.gte(str: String?): GteExpression {
return GteExpression(this, str)
}
infix fun Table.Column.gte(num: Number): GteExpression {
return GteExpression(this, num)
}
================================================
FILE: core/src/tel/egram/kuery/Subject.kt
================================================
package tel.egram.kuery
import tel.egram.kuery.ddl.*
import tel.egram.kuery.dml.*
open class Subject<T: Table> {
val table: T
private constructor(table: T) {
this.table = table
}
override fun toString(): String {
return table.toString()
}
class Over<T: Table>(table: T) : Subject<T>(table) {
inline fun create(definition: (T) -> Iterable<Definition>): CreateTableStatement<T> {
return CreateTableStatement(definition(table), this)
}
inline fun drop(): DropTableStatement<T> {
return DropTableStatement(this)
}
}
class From<T: Table>(table: T) : Subject<T>(table) {
inline fun <T2: Table> join(table2: T2): Join2Clause<T, T2> {
return Join2Clause(this, table2)
}
inline fun <T2: Table> outerJoin(table2: T2): Join2Clause<T, T2> {
return Join2Clause(this, table2, JoinType.OUTER)
}
inline fun where(predicate: (T) -> Predicate): WhereClause<T> {
return WhereClause(predicate(table), this)
}
inline fun groupBy(projection: (T) -> Iterable<Projection>): GroupClause<T> {
return GroupClause(projection(table), this, null)
}
inline fun orderBy(order: (T) -> Iterable<Ordering>): OrderClause<T> {
return OrderClause(order(table), this, null, null, null)
}
inline fun limit(limit: () -> String): LimitClause<T> {
return LimitClause(
limit(),
this,
null,
null,
null,
null)
}
inline fun offset(offset: () -> String): OffsetClause<T> {
return OffsetClause(
offset(),
limit { "-1" },
this,
null,
null,
null,
null)
}
inline fun select(projection: (T) -> Iterable<Projection>): SelectStatement<T> {
return SelectStatement(
projection(table),
this,
null,
null,
null,
null,
null,
null)
}
inline fun update(update: (T) -> Iterable<Assignment>): UpdateStatement<T> {
return UpdateStatement(
update(table),
this,
null)
}
inline fun delete(): DeleteStatement<T> {
return DeleteStatement(
this,
null
)
}
}
class Into<T: Table>(table: T) : Subject<T>(table) {
inline fun insert(insert: (T) -> Iterable<Assignment>): InsertStatement<T> {
return InsertStatement(insert(table), this)
}
}
}
inline fun <T: Table> over(table: T): Subject.Over<T> {
return Subject.Over(table)
}
inline fun <T: Table> from(table: T): Subject.From<T> {
return Subject.From(table)
}
inline fun <T: Table> into(table: T): Subject.Into<T> {
return Subject.Into(table)
}
================================================
FILE: core/src/tel/egram/kuery/Table.kt
================================================
package tel.egram.kuery
import tel.egram.kuery.ddl.Definition
import tel.egram.kuery.dml.*
open class Table(private val name: String) {
inner class Column(val name: String) : Projection {
val table: Table
get() = this@Table
val asc: Ordering
get() = Ordering.By(this, true)
val desc: Ordering
get() = Ordering.By(this, false)
operator fun invoke(column: Column): Assignment {
return Assignment.Value(this, column)
}
operator fun invoke(value: String?): Assignment {
return Assignment.Value(this, value)
}
operator fun invoke(value: Number): Assignment {
return Assignment.Value(this, value)
}
operator fun invoke(value: Boolean): Assignment {
return Assignment.Value(this, value)
}
override fun toString(): String {
return name
}
}
override fun toString(): String {
return name
}
}
operator fun Table.Column.rangeTo(column: Table.Column): Iterable<Table.Column> {
return listOf(this, column)
}
operator fun Iterable<Table.Column>.rangeTo(column: Table.Column): Iterable<Table.Column> {
return this.plusElement(column)
}
operator fun Iterable<Ordering>.rangeTo(ordering: Ordering): Iterable<Ordering> {
return if (this is Ordering) listOf(this, ordering) else this.plusElement(ordering)
}
operator fun Iterable<Assignment>.rangeTo(assignment: Assignment): Iterable<Assignment> {
return if (this is Assignment) listOf(this, assignment) else this.plusElement(assignment)
}
operator fun Iterable<Definition>.rangeTo(definition: Definition): Iterable<Definition> {
return if (this is Definition) listOf(this, definition) else this.plusElement(definition)
}
================================================
FILE: core/src/tel/egram/kuery/ddl/CreateTableStatement.kt
================================================
package tel.egram.kuery.ddl
import tel.egram.kuery.*
class CreateTableStatement<T: Table>(
val definitions: Iterable<Definition>,
val subject: Subject<T>) {
fun toString(dialect: Dialect): String {
return dialect.build(this)
}
}
================================================
FILE: core/src/tel/egram/kuery/ddl/Definition.kt
================================================
package tel.egram.kuery.ddl
import tel.egram.kuery.*
interface Definition : Iterable<Definition> {
val column: Table.Column
val type: String
override fun iterator(): Iterator<Definition> {
return object : Iterator<Definition> {
var valid = true
override fun hasNext(): Boolean {
return valid
}
override fun next(): Definition {
valid = false
return this@Definition
}
}
}
open class Column(override val column: Table.Column, override val type: String) : Definition
}
================================================
FILE: core/src/tel/egram/kuery/ddl/DropTableStatement.kt
================================================
package tel.egram.kuery.ddl
import tel.egram.kuery.*
class DropTableStatement<T: Table>(
val subject: Subject<T>) {
fun toString(dialect: Dialect): String {
return dialect.build(this)
}
}
================================================
FILE: core/src/tel/egram/kuery/dml/Assignment.kt
================================================
package tel.egram.kuery.dml
import tel.egram.kuery.Table
interface Assignment : Iterable<Assignment> {
val column: Table.Column
val value: Any?
override fun iterator(): Iterator<Assignment> {
return object : Iterator<Assignment> {
var valid = true
override fun hasNext(): Boolean {
return valid
}
override fun next(): Assignment {
valid = false
return this@Assignment
}
}
}
class Value(override val column: Table.Column, override val value: Any?) : Assignment
}
================================================
FILE: core/src/tel/egram/kuery/dml/DeleteStatement.kt
================================================
package tel.egram.kuery.dml
import tel.egram.kuery.*
class DeleteStatement<T: Table>(
val subject: Subject<T>,
val whereClause: WhereClause<T>?) {
fun toString(dialect: Dialect): String {
return dialect.build(this)
}
}
================================================
FILE: core/src/tel/egram/kuery/dml/GroupClause.kt
================================================
package tel.egram.kuery.dml
import tel.egram.kuery.*
class GroupClause<T: Table>(
val projection: Iterable<Projection>,
val subject: Subject<T>,
val whereClause: WhereClause<T>?) {
inline fun having(predicate: (T) -> Predicate): HavingClause<T> {
return HavingClause(predicate(subject.table), subject, this, whereClause)
}
inline fun orderBy(order: (T) -> Iterable<Ordering>): OrderClause<T> {
return OrderClause(order(subject.table), subject, whereClause, this, null)
}
inline fun limit(limit: () -> Any): LimitClause<T> {
return LimitClause(
limit(),
subject,
whereClause,
null,
this,
null)
}
inline fun offset(offset: () -> Any): OffsetClause<T> {
return OffsetClause(
offset(),
limit { "-1" },
subject,
whereClause,
null,
this,
null)
}
inline fun select(projection: (T) -> Iterable<Projection>): SelectStatement<T> {
return SelectStatement(
projection(subject.table),
subject,
whereClause,
null,
null,
null,
this,
null
)
}
}
class Group2Clause<T: Table, T2: Table>(
val projection: Iterable<Projection>,
val joinOn2Clause: JoinOn2Clause<T, T2>,
val where2Clause: Where2Clause<T, T2>?) {
inline fun having(predicate: (T, T2) -> Predicate): Having2Clause<T, T2> {
return Having2Clause(
predicate(joinOn2Clause.subject.table, joinOn2Clause.table2),
joinOn2Clause,
this,
where2Clause)
}
inline fun orderBy(order: (T, T2) -> Iterable<Ordering>): Order2Clause<T, T2> {
return Order2Clause(order(joinOn2Clause.subject.table, joinOn2Clause.table2), joinOn2Clause, where2Clause, this, null)
}
inline fun limit(limit: () -> Any): Limit2Clause<T, T2> {
return Limit2Clause(
limit(),
joinOn2Clause,
where2Clause,
null,
this,
null)
}
inline fun offset(offset: () -> Any): Offset2Clause<T, T2> {
return Offset2Clause(
offset(),
limit { "-1" },
joinOn2Clause,
where2Clause,
null,
this,
null)
}
inline fun select(projection: (T, T2) -> Iterable<Projection>): Select2Statement<T, T2> {
return Select2Statement(
projection(joinOn2Clause.subject.table, joinOn2Clause.table2),
joinOn2Clause,
where2Clause,
null,
null,
null,
this,
null
)
}
}
class Group3Clause<T: Table, T2: Table, T3: Table>(
val projection: Iterable<Projection>,
val joinOn3Clause: JoinOn3Clause<T, T2, T3>,
val where3Clause: Where3Clause<T, T2, T3>?) {
inline fun having(predicate: (T, T2, T3) -> Predicate): Having3Clause<T, T2, T3> {
return Having3Clause(
predicate(
joinOn3Clause.joinOn2Clause.subject.table,
joinOn3Clause.joinOn2Clause.table2,
joinOn3Clause.table3),
joinOn3Clause,
this,
where3Clause)
}
inline fun orderBy(order: (T, T2, T3) -> Iterable<Ordering>): Order3Clause<T, T2, T3> {
return Order3Clause(
order(joinOn3Clause.joinOn2Clause.subject.table, joinOn3Clause.joinOn2Clause.table2, joinOn3Clause.table3), joinOn3Clause, where3Clause, this, null)
}
inline fun limit(limit: () -> Any): Limit3Clause<T, T2, T3> {
return Limit3Clause(
limit(),
joinOn3Clause,
where3Clause,
null,
this,
null)
}
inline fun offset(offset: () -> Any): Offset3Clause<T, T2, T3> {
return Offset3Clause(
offset(),
limit { "-1" },
joinOn3Clause,
where3Clause,
null,
this,
null)
}
inline fun select(projection: (T, T2, T3) -> Iterable<Projection>): Select3Statement<T, T2, T3> {
return Select3Statement(
projection(
joinOn3Clause.joinOn2Clause.subject.table,
joinOn3Clause.joinOn2Clause.table2,
joinOn3Clause.table3
),
joinOn3Clause,
where3Clause,
null,
null,
null,
this,
null
)
}
}
class Group4Clause<T: Table, T2: Table, T3: Table, T4: Table>(
val projection: Iterable<Projection>,
val joinOn4Clause: JoinOn4Clause<T, T2, T3, T4>,
val where4Clause: Where4Clause<T, T2, T3, T4>?) {
inline fun having(predicate: (T, T2, T3, T4) -> Predicate): Having4Clause<T, T2, T3, T4> {
return Having4Clause(
predicate(
joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,
joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,
joinOn4Clause.joinOn3Clause.table3,
joinOn4Clause.table4),
joinOn4Clause,
this,
where4Clause)
}
inline fun orderBy(order: (T, T2, T3, T4) -> Iterable<Ordering>): Order4Clause<T, T2, T3, T4> {
return Order4Clause(
order(
joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,
joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,
joinOn4Clause.joinOn3Clause.table3,
joinOn4Clause.table4
),
joinOn4Clause,
where4Clause,
this,
null)
}
inline fun limit(limit: () -> Any): Limit4Clause<T, T2, T3, T4> {
return Limit4Clause(
limit(),
joinOn4Clause,
where4Clause,
null,
this,
null)
}
inline fun offset(offset: () -> Any): Offset4Clause<T, T2, T3, T4> {
return Offset4Clause(
offset(),
limit { "-1" },
joinOn4Clause,
where4Clause,
null,
this,
null)
}
inline fun select(projection: (T, T2, T3, T4) -> Iterable<Projection>): Select4Statement<T, T2, T3, T4> {
return Select4Statement(
projection(
joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,
joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,
joinOn4Clause.joinOn3Clause.table3,
joinOn4Clause.table4
),
joinOn4Clause,
where4Clause,
null,
null,
null,
this,
null
)
}
}
================================================
FILE: core/src/tel/egram/kuery/dml/HavingClause.kt
================================================
package tel.egram.kuery.dml
import tel.egram.kuery.*
class HavingClause<T: Table>(
val predicate: Predicate,
val subject: Subject<T>,
val groupClause: GroupClause<T>,
val whereClause: WhereClause<T>?) {
inline fun orderBy(order: (T) -> Iterable<Ordering>): OrderClause<T> {
return OrderClause(order(subject.table), subject, whereClause, groupClause, this)
}
inline fun limit(limit: () -> Any): LimitClause<T> {
return LimitClause(
limit(),
subject,
whereClause,
null,
groupClause,
this)
}
inline fun offset(offset: () -> Any): OffsetClause<T> {
return OffsetClause(
offset(),
limit { "-1" },
subject,
whereClause,
null,
groupClause,
this)
}
inline fun select(projection: (T) -> Iterable<Projection>): SelectStatement<T> {
return SelectStatement(
projection(subject.table),
subject,
whereClause,
null,
null,
null,
groupClause,
this)
}
}
class Having2Clause<T: Table, T2: Table>(
val predicate: Predicate,
val joinOn2Clause: JoinOn2Clause<T, T2>,
val group2Clause: Group2Clause<T, T2>,
val where2Clause: Where2Clause<T, T2>?) {
inline fun orderBy(order: (T, T2) -> Iterable<Ordering>): Order2Clause<T, T2> {
return Order2Clause(order(joinOn2Clause.subject.table, joinOn2Clause.table2), joinOn2Clause, where2Clause, group2Clause, this)
}
inline fun limit(limit: () -> Any): Limit2Clause<T, T2> {
return Limit2Clause(
limit(),
joinOn2Clause,
where2Clause,
null,
group2Clause,
this)
}
inline fun offset(offset: () -> Any): Offset2Clause<T, T2> {
return Offset2Clause(
offset(),
limit { "-1" },
joinOn2Clause,
where2Clause,
null,
group2Clause,
this)
}
inline fun select(projection: (T, T2) -> Iterable<Projection>): Select2Statement<T, T2> {
return Select2Statement(
projection(joinOn2Clause.subject.table, joinOn2Clause.table2),
joinOn2Clause,
where2Clause,
null,
null,
null,
group2Clause,
this
)
}
}
class Having3Clause<T: Table, T2: Table, T3: Table>(
val predicate: Predicate,
val joinOn3Clause: JoinOn3Clause<T, T2, T3>,
val group3Clause: Group3Clause<T, T2, T3>,
val where3Clause: Where3Clause<T, T2, T3>?) {
inline fun orderBy(order: (T, T2, T3) -> Iterable<Ordering>): Order3Clause<T, T2, T3> {
return Order3Clause(
order(joinOn3Clause.joinOn2Clause.subject.table, joinOn3Clause.joinOn2Clause.table2, joinOn3Clause.table3), joinOn3Clause, where3Clause, group3Clause, this)
}
inline fun limit(limit: () -> Any): Limit3Clause<T, T2, T3> {
return Limit3Clause(
limit(),
joinOn3Clause,
where3Clause,
null,
group3Clause,
this)
}
inline fun offset(offset: () -> Any): Offset3Clause<T, T2, T3> {
return Offset3Clause(
offset(),
limit { "-1" },
joinOn3Clause,
where3Clause,
null,
group3Clause,
this)
}
inline fun select(projection: (T, T2, T3) -> Iterable<Projection>): Select3Statement<T, T2, T3> {
return Select3Statement(
projection(
joinOn3Clause.joinOn2Clause.subject.table,
joinOn3Clause.joinOn2Clause.table2,
joinOn3Clause.table3
),
joinOn3Clause,
where3Clause,
null,
null,
null,
group3Clause,
this
)
}
}
class Having4Clause<T: Table, T2: Table, T3: Table, T4: Table>(
val predicate: Predicate,
val joinOn4Clause: JoinOn4Clause<T, T2, T3, T4>,
val group4Clause: Group4Clause<T, T2, T3, T4>,
val where4Clause: Where4Clause<T, T2, T3, T4>?) {
inline fun orderBy(order: (T, T2, T3, T4) -> Iterable<Ordering>): Order4Clause<T, T2, T3, T4> {
return Order4Clause(
order(
joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,
joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,
joinOn4Clause.joinOn3Clause.table3,
joinOn4Clause.table4
),
joinOn4Clause,
where4Clause,
group4Clause,
this)
}
inline fun limit(limit: () -> Any): Limit4Clause<T, T2, T3, T4> {
return Limit4Clause(
limit(),
joinOn4Clause,
where4Clause,
null,
group4Clause,
this)
}
inline fun offset(offset: () -> Any): Offset4Clause<T, T2, T3, T4> {
return Offset4Clause(
offset(),
limit { "-1" },
joinOn4Clause,
where4Clause,
null,
group4Clause,
this)
}
inline fun select(projection: (T, T2, T3, T4) -> Iterable<Projection>): Select4Statement<T, T2, T3, T4> {
return Select4Statement(
projection(
joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,
joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,
joinOn4Clause.joinOn3Clause.table3,
joinOn4Clause.table4
),
joinOn4Clause,
where4Clause,
null,
null,
null,
group4Clause,
this
)
}
}
================================================
FILE: core/src/tel/egram/kuery/dml/InsertStatement.kt
================================================
package tel.egram.kuery.dml
import tel.egram.kuery.*
class InsertStatement<T: Table>(
val assignments: Iterable<Assignment>,
val subject: Subject<T>) {
fun toString(dialect: Dialect): String {
return dialect.build(this)
}
}
================================================
FILE: core/src/tel/egram/kuery/dml/JoinClause.kt
================================================
package tel.egram.kuery.dml
import tel.egram.kuery.*
class Join2Clause<T: Table, T2: Table>(
val subject: Subject<T>,
val table2: T2,
val type: JoinType = JoinType.INNER) {
inline fun on(condition: (T, T2) -> Predicate): JoinOn2Clause<T, T2> {
return JoinOn2Clause(
subject,
table2,
type,
condition(subject.table, table2)
)
}
}
class JoinOn2Clause<T: Table, T2: Table>(
val subject: Subject<T>,
val table2: T2,
val type: JoinType,
val condition: Predicate) {
inline fun <T3: Table> join(table3: T3): Join3Clause<T, T2, T3> {
return Join3Clause(this, table3)
}
inline fun <T3: Table> outerJoin(table3: T3): Join3Clause<T, T2, T3> {
return Join3Clause(this, table3, JoinType.OUTER)
}
inline fun where(predicate: (T, T2) -> Predicate): Where2Clause<T, T2> {
return Where2Clause(predicate(subject.table, table2), this)
}
inline fun groupBy(group: (T, T2) -> Iterable<Projection>): Group2Clause<T, T2> {
return Group2Clause(group(subject.table, table2), this, null)
}
inline fun orderBy(order: (T, T2) -> Iterable<Ordering>): Order2Clause<T, T2> {
return Order2Clause(order(subject.table, table2), this, null, null, null)
}
inline fun limit(limit: () -> Any): Limit2Clause<T, T2> {
return Limit2Clause(
limit(),
this,
null,
null,
null,
null)
}
inline fun offset(offset: () -> String): Offset2Clause<T, T2> {
return Offset2Clause(
offset(),
limit { "-1" },
this,
null,
null,
null,
null)
}
inline fun select(projection: (T, T2) -> Iterable<Projection>): Select2Statement<T, T2> {
return Select2Statement(
projection(subject.table, table2),
this,
null,
null,
null,
null,
null,
null)
}
}
class Join3Clause<T: Table, T2: Table, T3: Table>(
val joinOn2Clause: JoinOn2Clause<T, T2>,
val table3: T3,
val type: JoinType = JoinType.INNER) {
inline fun on(condition: (T, T2, T3) -> Predicate): JoinOn3Clause<T, T2, T3> {
return JoinOn3Clause(
joinOn2Clause,
table3,
type,
condition(joinOn2Clause.subject.table, joinOn2Clause.table2, table3)
)
}
}
class JoinOn3Clause<T: Table, T2: Table, T3: Table>(
val joinOn2Clause: JoinOn2Clause<T, T2>,
val table3: T3,
val type: JoinType,
val condition: Predicate) {
inline fun <T4: Table> join(table4: T4): Join4Clause<T, T2, T3, T4> {
return Join4Clause(this, table4)
}
inline fun <T4: Table> outerJoin(table4: T4): Join4Clause<T, T2, T3, T4> {
return Join4Clause(this, table4, JoinType.OUTER)
}
inline fun where(predicate: (T, T2, T3) -> Predicate): Where3Clause<T, T2, T3> {
return Where3Clause(predicate(joinOn2Clause.subject.table, joinOn2Clause.table2, table3), this)
}
inline fun groupBy(group: (T, T2, T3) -> Iterable<Projection>): Group3Clause<T, T2, T3> {
return Group3Clause(
group(joinOn2Clause.subject.table, joinOn2Clause.table2, table3),
this,
null
)
}
inline fun orderBy(order: (T, T2, T3) -> Iterable<Ordering>): Order3Clause<T, T2, T3> {
return Order3Clause(
order(joinOn2Clause.subject.table, joinOn2Clause.table2, table3),
this,
null,
null,
null
)
}
inline fun limit(limit: () -> Any): Limit3Clause<T, T2, T3> {
return Limit3Clause(
limit(),
this,
null,
null,
null,
null)
}
inline fun offset(offset: () -> String): Offset3Clause<T, T2, T3> {
return Offset3Clause(
offset(),
limit { "-1" },
this,
null,
null,
null,
null)
}
inline fun select(projection: (T, T2, T3) -> Iterable<Projection>): Select3Statement<T, T2, T3> {
return Select3Statement(
projection(joinOn2Clause.subject.table, joinOn2Clause.table2, table3),
this,
null,
null,
null,
null,
null,
null)
}
}
class Join4Clause<T: Table, T2: Table, T3: Table, T4: Table>(
val joinOn3Clause: JoinOn3Clause<T, T2, T3>,
val table4: T4,
val type: JoinType = JoinType.INNER) {
inline fun on(condition: (T, T2, T3, T4) -> Predicate): JoinOn4Clause<T, T2, T3, T4> {
return JoinOn4Clause(
joinOn3Clause,
table4,
type,
condition(joinOn3Clause.joinOn2Clause.subject.table, joinOn3Clause.joinOn2Clause.table2, joinOn3Clause.table3, table4)
)
}
}
class JoinOn4Clause<T: Table, T2: Table, T3: Table, T4: Table>(
val joinOn3Clause: JoinOn3Clause<T, T2, T3>,
val table4: T4,
val type: JoinType,
val condition: Predicate) {
inline fun where(predicate: (T, T2, T3, T4) -> Predicate): Where4Clause<T, T2, T3, T4> {
return Where4Clause(
predicate(
joinOn3Clause.joinOn2Clause.subject.table,
joinOn3Clause.joinOn2Clause.table2,
joinOn3Clause.table3,
table4
),
this)
}
inline fun groupBy(group: (T, T2, T3, T4) -> Iterable<Projection>): Group4Clause<T, T2, T3, T4> {
return Group4Clause(
group(
joinOn3Clause.joinOn2Clause.subject.table,
joinOn3Clause.joinOn2Clause.table2,
joinOn3Clause.table3,
table4
),
this,
null
)
}
inline fun orderBy(order: (T, T2, T3, T4) -> Iterable<Ordering>): Order4Clause<T, T2, T3, T4> {
return Order4Clause(
order(
joinOn3Clause.joinOn2Clause.subject.table,
joinOn3Clause.joinOn2Clause.table2,
joinOn3Clause.table3,
table4
),
this,
null,
null,
null
)
}
inline fun limit(limit: () -> Any): Limit4Clause<T, T2, T3, T4> {
return Limit4Clause(
limit(),
this,
null,
null,
null,
null)
}
inline fun offset(offset: () -> String): Offset4Clause<T, T2, T3, T4> {
return Offset4Clause(
offset(),
limit { "-1" },
this,
null,
null,
null,
null)
}
inline fun select(projection: (T, T2, T3, T4) -> Iterable<Projection>): Select4Statement<T, T2, T3, T4> {
return Select4Statement(
projection(
joinOn3Clause.joinOn2Clause.subject.table,
joinOn3Clause.joinOn2Clause.table2,
joinOn3Clause.table3,
table4
),
this,
null,
null,
null,
null,
null,
null)
}
}
enum class JoinType {
INNER,
OUTER
}
================================================
FILE: core/src/tel/egram/kuery/dml/LimitClause.kt
================================================
package tel.egram.kuery.dml
import tel.egram.kuery.*
class LimitClause<T: Table>(
val limit: Any,
val subject: Subject<T>,
val whereClause: WhereClause<T>?,
val orderClause: OrderClause<T>?,
val groupClause: GroupClause<T>?,
val havingClause: HavingClause<T>?) {
inline fun offset(offset: () -> Any): OffsetClause<T> {
return OffsetClause(
offset(),
this,
subject,
whereClause,
orderClause,
groupClause,
havingClause)
}
inline fun select(projection: (T) -> Iterable<Projection>): SelectStatement<T> {
return SelectStatement(
projection(subject.table),
subject,
whereClause,
orderClause,
this,
null,
groupClause,
havingClause)
}
}
class Limit2Clause<T: Table, T2: Table>(
val limit: Any,
val joinOn2Clause: JoinOn2Clause<T, T2>,
val where2Clause: Where2Clause<T, T2>?,
val order2Clause: Order2Clause<T, T2>?,
val group2Clause: Group2Clause<T, T2>?,
val having2Clause: Having2Clause<T, T2>?) {
inline fun offset(offset: () -> Any): Offset2Clause<T, T2> {
return Offset2Clause(
offset(),
this,
joinOn2Clause,
where2Clause,
order2Clause,
group2Clause,
having2Clause)
}
inline fun select(projection: (T, T2) -> Iterable<Projection>): Select2Statement<T, T2> {
return Select2Statement(
projection(joinOn2Clause.subject.table, joinOn2Clause.table2),
joinOn2Clause,
where2Clause,
order2Clause,
this,
null,
group2Clause,
having2Clause)
}
}
class Limit3Clause<T: Table, T2: Table, T3: Table>(
val limit: Any,
val joinOn3Clause: JoinOn3Clause<T, T2, T3>,
val where3Clause: Where3Clause<T, T2, T3>?,
val order3Clause: Order3Clause<T, T2, T3>?,
val group3Clause: Group3Clause<T, T2, T3>?,
val having3Clause: Having3Clause<T, T2, T3>?) {
inline fun offset(offset: () -> Any): Offset3Clause<T, T2, T3> {
return Offset3Clause(
offset(),
this,
joinOn3Clause,
where3Clause,
order3Clause,
group3Clause,
having3Clause)
}
inline fun select(projection: (T, T2, T3) -> Iterable<Projection>): Select3Statement<T, T2, T3> {
return Select3Statement(
projection(joinOn3Clause.joinOn2Clause.subject.table, joinOn3Clause.joinOn2Clause.table2, joinOn3Clause.table3),
joinOn3Clause,
where3Clause,
order3Clause,
this,
null,
group3Clause,
having3Clause)
}
}
class Limit4Clause<T: Table, T2: Table, T3: Table, T4: Table>(
val limit: Any,
val joinOn4Clause: JoinOn4Clause<T, T2, T3, T4>,
val where4Clause: Where4Clause<T, T2, T3, T4>?,
val order4Clause: Order4Clause<T, T2, T3, T4>?,
val group4Clause: Group4Clause<T, T2, T3, T4>?,
val having4Clause: Having4Clause<T, T2, T3, T4>?) {
inline fun offset(offset: () -> Any): Offset4Clause<T, T2, T3, T4> {
return Offset4Clause(
offset(),
this,
joinOn4Clause,
where4Clause,
order4Clause,
group4Clause,
having4Clause)
}
inline fun select(projection: (T, T2, T3, T4) -> Iterable<Projection>): Select4Statement<T, T2, T3, T4> {
return Select4Statement(
projection(
joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,
joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,
joinOn4Clause.joinOn3Clause.table3,
joinOn4Clause.table4
),
joinOn4Clause,
where4Clause,
order4Clause,
this,
null,
group4Clause,
having4Clause)
}
}
================================================
FILE: core/src/tel/egram/kuery/dml/OffsetClause.kt
================================================
package tel.egram.kuery.dml
import tel.egram.kuery.*
class OffsetClause<T: Table>(
val offset: Any,
val limit: LimitClause<T>,
val subject: Subject<T>,
val whereClause: WhereClause<T>?,
val orderClause: OrderClause<T>?,
val groupClause: GroupClause<T>?,
val havingClause: HavingClause<T>?) {
inline fun select(projection: (T) -> Iterable<Projection>): SelectStatement<T> {
return SelectStatement(
projection(subject.table),
subject,
whereClause,
orderClause,
limit,
this,
groupClause,
havingClause)
}
}
class Offset2Clause<T: Table, T2: Table>(
val offset: Any,
val limit2Clause: Limit2Clause<T, T2>,
val joinOn2Clause: JoinOn2Clause<T, T2>,
val whereClause: Where2Clause<T, T2>?,
val orderClause: Order2Clause<T, T2>?,
val group2Clause: Group2Clause<T, T2>?,
val having2Clause: Having2Clause<T, T2>?) {
inline fun select(projection: (T, T2) -> Iterable<Projection>): Select2Statement<T, T2> {
return Select2Statement(
projection(joinOn2Clause.subject.table, joinOn2Clause.table2),
joinOn2Clause,
whereClause,
orderClause,
limit2Clause,
this,
group2Clause,
having2Clause)
}
}
class Offset3Clause<T: Table, T2: Table, T3: Table>(
val offset: Any,
val limit3Clause: Limit3Clause<T, T2, T3>,
val joinOn3Clause: JoinOn3Clause<T, T2, T3>,
val where3Clause: Where3Clause<T, T2, T3>?,
val order3Clause: Order3Clause<T, T2, T3>?,
val group3Clause: Group3Clause<T, T2, T3>?,
val having3Clause: Having3Clause<T, T2, T3>?) {
inline fun select(projection: (T, T2, T3) -> Iterable<Projection>): Select3Statement<T, T2, T3> {
return Select3Statement(
projection(joinOn3Clause.joinOn2Clause.subject.table, joinOn3Clause.joinOn2Clause.table2, joinOn3Clause.table3),
joinOn3Clause,
where3Clause,
order3Clause,
limit3Clause,
this,
group3Clause,
having3Clause)
}
}
class Offset4Clause<T: Table, T2: Table, T3: Table, T4: Table>(
val offset: Any,
val limit4Clause: Limit4Clause<T, T2, T3, T4>,
val joinOn4Clause: JoinOn4Clause<T, T2, T3, T4>,
val where4Clause: Where4Clause<T, T2, T3, T4>?,
val order4Clause: Order4Clause<T, T2, T3, T4>?,
val group4Clause: Group4Clause<T, T2, T3, T4>?,
val having4Clause: Having4Clause<T, T2, T3, T4>?) {
inline fun select(projection: (T, T2, T3, T4) -> Iterable<Projection>): Select4Statement<T, T2, T3, T4> {
return Select4Statement(
projection(
joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,
joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,
joinOn4Clause.joinOn3Clause.table3,
joinOn4Clause.table4
),
joinOn4Clause,
where4Clause,
order4Clause,
limit4Clause,
this,
group4Clause,
having4Clause)
}
}
================================================
FILE: core/src/tel/egram/kuery/dml/OrderClause.kt
================================================
package tel.egram.kuery.dml
import tel.egram.kuery.*
class OrderClause<T: Table>(
val orderings: Iterable<Ordering>,
val subject: Subject<T>,
val whereClause: WhereClause<T>?,
val groupClause: GroupClause<T>?,
val havingClause: HavingClause<T>?) {
inline fun limit(limit: () -> Any): LimitClause<T> {
return LimitClause(
limit(),
subject,
whereClause,
this,
groupClause,
havingClause)
}
inline fun offset(offset: () -> Any): OffsetClause<T> {
return OffsetClause(
offset(),
limit { "-1" },
subject,
whereClause,
this,
groupClause,
havingClause)
}
inline fun select(projection: (T) -> Iterable<Projection>): SelectStatement<T> {
return SelectStatement(
projection(subject.table),
subject,
whereClause,
this,
null,
null,
groupClause,
havingClause)
}
}
class Order2Clause<T: Table, T2: Table>(
val orderings: Iterable<Ordering>,
val joinOn2Clause: JoinOn2Clause<T, T2>,
val where2Clause: Where2Clause<T, T2>?,
val group2Clause: Group2Clause<T, T2>?,
val having2Clause: Having2Clause<T, T2>?) {
inline fun limit(limit: () -> Any): Limit2Clause<T, T2> {
return Limit2Clause(
limit(),
joinOn2Clause,
where2Clause,
this,
group2Clause,
having2Clause)
}
inline fun offset(offset: () -> Any): Offset2Clause<T, T2> {
return Offset2Clause(
offset(),
limit { "-1" },
joinOn2Clause,
where2Clause,
this,
group2Clause,
having2Clause)
}
inline fun select(projection: (T, T2) -> Iterable<Projection>): Select2Statement<T, T2> {
return Select2Statement(
projection(joinOn2Clause.subject.table, joinOn2Clause.table2),
joinOn2Clause,
where2Clause,
this,
null,
null,
group2Clause,
having2Clause)
}
}
class Order3Clause<T: Table, T2: Table, T3: Table>(
val orderings: Iterable<Ordering>,
val joinOn3Clause: JoinOn3Clause<T, T2, T3>,
val where3Clause: Where3Clause<T, T2, T3>?,
val group3Clause: Group3Clause<T, T2, T3>?,
val having3Clause: Having3Clause<T, T2, T3>?) {
inline fun limit(limit: () -> Any): Limit3Clause<T, T2, T3> {
return Limit3Clause(
limit(),
joinOn3Clause,
where3Clause,
this,
group3Clause,
having3Clause)
}
inline fun offset(offset: () -> Any): Offset3Clause<T, T2, T3> {
return Offset3Clause(
offset(),
limit { "-1" },
joinOn3Clause,
where3Clause,
this,
group3Clause,
having3Clause)
}
inline fun select(projection: (T, T2, T3) -> Iterable<Projection>): Select3Statement<T, T2, T3> {
return Select3Statement(
projection(joinOn3Clause.joinOn2Clause.subject.table, joinOn3Clause.joinOn2Clause.table2, joinOn3Clause.table3),
joinOn3Clause,
where3Clause,
this,
null,
null,
group3Clause,
having3Clause)
}
}
class Order4Clause<T: Table, T2: Table, T3: Table, T4: Table>(
val orderings: Iterable<Ordering>,
val joinOn4Clause: JoinOn4Clause<T, T2, T3, T4>,
val where4Clause: Where4Clause<T, T2, T3, T4>?,
val group4Clause: Group4Clause<T, T2, T3, T4>?,
val having4Clause: Having4Clause<T, T2, T3, T4>?) {
inline fun limit(limit: () -> Any): Limit4Clause<T, T2, T3, T4> {
return Limit4Clause(
limit(),
joinOn4Clause,
where4Clause,
this,
group4Clause,
having4Clause)
}
inline fun offset(offset: () -> Any): Offset4Clause<T, T2, T3, T4> {
return Offset4Clause(
offset(),
limit { "-1" },
joinOn4Clause,
where4Clause,
this,
group4Clause,
having4Clause)
}
inline fun select(projection: (T, T2, T3, T4) -> Iterable<Projection>): Select4Statement<T, T2, T3, T4> {
return Select4Statement(
projection(
joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,
joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,
joinOn4Clause.joinOn3Clause.table3,
joinOn4Clause.table4
),
joinOn4Clause,
where4Clause,
this,
null,
null,
group4Clause,
having4Clause)
}
}
================================================
FILE: core/src/tel/egram/kuery/dml/Ordering.kt
================================================
package tel.egram.kuery.dml
interface Ordering : Iterable<Ordering> {
val key: Any
val asc: Boolean
override fun iterator(): Iterator<Ordering> {
return object : Iterator<Ordering> {
var valid = true
override fun hasNext(): Boolean {
return valid
}
override fun next(): Ordering {
valid = false
return this@Ordering
}
}
}
class By(override val key: Any, override val asc: Boolean) : Ordering
}
================================================
FILE: core/src/tel/egram/kuery/dml/Projection.kt
================================================
package tel.egram.kuery.dml
interface Projection : Iterable<Projection> {
override fun iterator(): Iterator<Projection> {
return object : Iterator<Projection> {
var valid = true
override fun hasNext(): Boolean {
return valid
}
override fun next(): Projection {
valid = false
return this@Projection
}
}
}
}
================================================
FILE: core/src/tel/egram/kuery/dml/SelectStatement.kt
================================================
package tel.egram.kuery.dml
import tel.egram.kuery.*
class SelectStatement<T: Table>(
val projection: Iterable<Projection>,
val subject: Subject<T>,
val whereClause: WhereClause<T>?,
val orderClause: OrderClause<T>?,
val limitClause: LimitClause<T>?,
val offsetClause: OffsetClause<T>?,
val groupClause: GroupClause<T>?,
val havingClause: HavingClause<T>?) {
fun toString(dialect: Dialect): String {
return dialect.build(this)
}
}
class Select2Statement<T: Table, T2: Table>(
val projection: Iterable<Projection>,
val joinOn2Clause: JoinOn2Clause<T, T2>,
val where2Clause: Where2Clause<T, T2>?,
val order2Clause: Order2Clause<T, T2>?,
val limit2Clause: Limit2Clause<T, T2>?,
val offset2Clause: Offset2Clause<T, T2>?,
val group2Clause: Group2Clause<T, T2>?,
val having2Clause: Having2Clause<T, T2>?) {
fun toString(dialect: Dialect): String {
return dialect.build(this)
}
}
class Select3Statement<T: Table, T2: Table, T3: Table>(
val projection: Iterable<Projection>,
val joinOn3Clause: JoinOn3Clause<T, T2, T3>,
val where3Clause: Where3Clause<T, T2, T3>?,
val order3Clause: Order3Clause<T, T2, T3>?,
val limit3Clause: Limit3Clause<T, T2, T3>?,
val offset3Clause: Offset3Clause<T, T2, T3>?,
val group3Clause: Group3Clause<T, T2, T3>?,
val having3Clause: Having3Clause<T, T2, T3>?) {
fun toString(dialect: Dialect): String {
return dialect.build(this)
}
}
class Select4Statement<T: Table, T2: Table, T3: Table, T4: Table>(
val projection: Iterable<Projection>,
val joinOn4Clause: JoinOn4Clause<T, T2, T3, T4>,
val where4Clause: Where4Clause<T, T2, T3, T4>?,
val order4Clause: Order4Clause<T, T2, T3, T4>?,
val limit4Clause: Limit4Clause<T, T2, T3, T4>?,
val offset4Clause: Offset4Clause<T, T2, T3, T4>?,
val group4Clause: Group4Clause<T, T2, T3, T4>?,
val having4Clause: Having4Clause<T, T2, T3, T4>?) {
fun toString(dialect: Dialect): String {
return dialect.build(this)
}
}
================================================
FILE: core/src/tel/egram/kuery/dml/UpdateStatement.kt
================================================
package tel.egram.kuery.dml
import tel.egram.kuery.*
class UpdateStatement<T: Table>(
val assignments: Iterable<Assignment>,
val subject: Subject<T>,
val whereClause: WhereClause<T>?) {
fun toString(dialect: Dialect): String {
return dialect.build(this)
}
}
================================================
FILE: core/src/tel/egram/kuery/dml/WhereClause.kt
================================================
package tel.egram.kuery.dml
import tel.egram.kuery.Predicate
import tel.egram.kuery.Subject
import tel.egram.kuery.Table
class WhereClause<T: Table>(
val predicate: Predicate,
val subject: Subject<T>) {
inline fun groupBy(group: (T) -> Iterable<Projection>): GroupClause<T> {
return GroupClause(group(subject.table), subject, this)
}
inline fun orderBy(order: (T) -> Iterable<Ordering>): OrderClause<T> {
return OrderClause(order(subject.table), subject, this, null, null)
}
inline fun limit(limit: () -> Any): LimitClause<T> {
return LimitClause(
limit(),
subject,
this,
null,
null,
null)
}
inline fun offset(offset: () -> Any): OffsetClause<T> {
return OffsetClause(
offset(),
limit { "-1" },
subject,
this,
null,
null,
null)
}
inline fun select(projection: (T) -> Iterable<Projection>): SelectStatement<T> {
return SelectStatement(
projection(subject.table),
subject,
this,
null,
null,
null,
null,
null
)
}
inline fun selectAll(): SelectStatement<T> {
return SelectStatement(
listOf(),
subject,
this,
null,
null,
null,
null,
null
)
}
inline fun update(value: (T) -> Iterable<Assignment>): UpdateStatement<T> {
return UpdateStatement(value(subject.table), subject, this)
}
inline fun delete(): DeleteStatement<T> {
return DeleteStatement(subject, this)
}
}
class Where2Clause<T: Table, T2: Table>(
val predicate: Predicate,
val joinOn2Clause: JoinOn2Clause<T, T2>) {
inline fun groupBy(group: (T, T2) -> Iterable<Projection>): Group2Clause<T, T2> {
return Group2Clause(group(joinOn2Clause.subject.table, joinOn2Clause.table2), joinOn2Clause, this)
}
inline fun orderBy(order: (T, T2) -> Iterable<Ordering>): Order2Clause<T, T2> {
return Order2Clause(order(joinOn2Clause.subject.table, joinOn2Clause.table2), joinOn2Clause, this, null, null)
}
inline fun limit(limit: () -> Any): Limit2Clause<T, T2> {
return Limit2Clause(
limit(),
joinOn2Clause,
this,
null,
null,
null)
}
inline fun offset(offset: () -> Any): Offset2Clause<T, T2> {
return Offset2Clause(
offset(),
limit { "-1" },
joinOn2Clause,
this,
null,
null,
null)
}
inline fun select(projection: (T, T2) -> Iterable<Projection>): Select2Statement<T, T2> {
return Select2Statement(
projection(joinOn2Clause.subject.table, joinOn2Clause.table2),
joinOn2Clause,
this,
null,
null,
null,
null,
null
)
}
}
class Where3Clause<T: Table, T2: Table, T3: Table>(
val predicate: Predicate,
val joinOn3Clause: JoinOn3Clause<T, T2, T3>) {
inline fun groupBy(group: (T, T2, T3) -> Iterable<Projection>): Group3Clause<T, T2, T3> {
return Group3Clause(
group(joinOn3Clause.joinOn2Clause.subject.table, joinOn3Clause.joinOn2Clause.table2, joinOn3Clause.table3), joinOn3Clause, this)
}
inline fun orderBy(order: (T, T2, T3) -> Iterable<Ordering>): Order3Clause<T, T2, T3> {
return Order3Clause(
order(joinOn3Clause.joinOn2Clause.subject.table, joinOn3Clause.joinOn2Clause.table2, joinOn3Clause.table3), joinOn3Clause, this, null, null)
}
inline fun limit(limit: () -> Any): Limit3Clause<T, T2, T3> {
return Limit3Clause(
limit(),
joinOn3Clause,
this,
null,
null,
null)
}
inline fun offset(offset: () -> Any): Offset3Clause<T, T2, T3> {
return Offset3Clause(
offset(),
limit { "-1" },
joinOn3Clause,
this,
null,
null,
null)
}
inline fun select(projection: (T, T2, T3) -> Iterable<Projection>): Select3Statement<T, T2, T3> {
return Select3Statement(
projection(
joinOn3Clause.joinOn2Clause.subject.table,
joinOn3Clause.joinOn2Clause.table2,
joinOn3Clause.table3
),
joinOn3Clause,
this,
null,
null,
null,
null,
null
)
}
}
class Where4Clause<T: Table, T2: Table, T3: Table, T4: Table>(
val predicate: Predicate,
val joinOn4Clause: JoinOn4Clause<T, T2, T3, T4>) {
inline fun groupBy(group: (T, T2, T3, T4) -> Iterable<Projection>): Group4Clause<T, T2, T3, T4> {
return Group4Clause(
group(
joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,
joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,
joinOn4Clause.joinOn3Clause.table3,
joinOn4Clause.table4
),
joinOn4Clause,
this)
}
inline fun orderBy(order: (T, T2, T3, T4) -> Iterable<Ordering>): Order4Clause<T, T2, T3, T4> {
return Order4Clause(
order(
joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,
joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,
joinOn4Clause.joinOn3Clause.table3,
joinOn4Clause.table4
),
joinOn4Clause,
this,
null,
null)
}
inline fun limit(limit: () -> Any): Limit4Clause<T, T2, T3, T4> {
return Limit4Clause(
limit(),
joinOn4Clause,
this,
null,
null,
null)
}
inline fun offset(offset: () -> Any): Offset4Clause<T, T2, T3, T4> {
return Offset4Clause(
offset(),
limit { "-1" },
joinOn4Clause,
this,
null,
null,
null)
}
inline fun select(projection: (T, T2, T3, T4) -> Iterable<Projection>): Select4Statement<T, T2, T3, T4> {
return Select4Statement(
projection(
joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,
joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,
joinOn4Clause.joinOn3Clause.table3,
joinOn4Clause.table4
),
joinOn4Clause,
this,
null,
null,
null,
null,
null
)
}
}
================================================
FILE: gradle/wrapper/gradle-wrapper.properties
================================================
#Mon Oct 19 12:09:08 BRST 2015
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-2.14-all.zip
================================================
FILE: gradle.properties
================================================
# Project-wide Gradle settings.
# IDE (e.g. Android Studio) users:
# Gradle settings configured through the IDE *will override*
# any settings specified in this file.
# For more details on how to configure your build environment visit
# http://www.gradle.org/docs/current/userguide/build_environment.html
# The Gradle daemon aims to improve the startup and execution time of Gradle.
# When set to true the Gradle daemon is to run the build.
# org.gradle.daemon=true
# Specifies the JVM arguments used for the daemon process.
# The setting is particularly useful for tweaking memory settings.
# Default value: -Xmx10248m -XX:MaxPermSize=256m
# org.gradle.jvmargs=-Xmx4096m -XX:MaxPermSize=1024m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
# When configured, Gradle will run in incubating parallel mode.
# This option should only be used with decoupled projects. More details, visit
# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
# org.gradle.parallel=true
# Enables new incubating mode that makes Gradle selective when configuring projects.
# Only relevant projects are configured which results in faster builds for large multi-projects.
# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:configuration_on_demand
# org.gradle.configureondemand=true
================================================
FILE: gradlew
================================================
#!/usr/bin/env bash
##############################################################################
##
## Gradle start up script for UN*X
##
##############################################################################
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS=""
APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"`
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"
warn ( ) {
echo "$*"
}
die ( ) {
echo
echo "$*"
echo
exit 1
}
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
case "`uname`" in
CYGWIN* )
cygwin=true
;;
Darwin* )
darwin=true
;;
MINGW* )
msys=true
;;
esac
# For Cygwin, ensure paths are in UNIX format before anything is touched.
if $cygwin ; then
[ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
fi
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
PRG="$0"
# Need this for relative symlinks.
while [ -h "$PRG" ] ; do
ls=`ls -ld "$PRG"`
link=`expr "$ls" : '.*-> \(.*\)$'`
if expr "$link" : '/.*' > /dev/null; then
PRG="$link"
else
PRG=`dirname "$PRG"`"/$link"
fi
done
SAVED="`pwd`"
cd "`dirname \"$PRG\"`/" >&-
APP_HOME="`pwd -P`"
cd "$SAVED" >&-
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD="$JAVA_HOME/jre/sh/java"
else
JAVACMD="$JAVA_HOME/bin/java"
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD="java"
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
# Increase the maximum file descriptors if we can.
if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
MAX_FD_LIMIT=`ulimit -H -n`
if [ $? -eq 0 ] ; then
if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
MAX_FD="$MAX_FD_LIMIT"
fi
ulimit -n $MAX_FD
if [ $? -ne 0 ] ; then
warn "Could not set maximum file descriptor limit: $MAX_FD"
fi
else
warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
fi
fi
# For Darwin, add options to specify how the application appears in the dock
if $darwin; then
GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
fi
# For Cygwin, switch paths to Windows format before running java
if $cygwin ; then
APP_HOME=`cygpath --path --mixed "$APP_HOME"`
CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
# We build the pattern for arguments to be converted via cygpath
ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
SEP=""
for dir in $ROOTDIRSRAW ; do
ROOTDIRS="$ROOTDIRS$SEP$dir"
SEP="|"
done
OURCYGPATTERN="(^($ROOTDIRS))"
# Add a user-defined pattern to the cygpath arguments
if [ "$GRADLE_CYGPATTERN" != "" ] ; then
OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
fi
# Now convert the arguments - kludge to limit ourselves to /bin/sh
i=0
for arg in "$@" ; do
CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
else
eval `echo args$i`="\"$arg\""
fi
i=$((i+1))
done
case $i in
(0) set -- ;;
(1) set -- "$args0" ;;
(2) set -- "$args0" "$args1" ;;
(3) set -- "$args0" "$args1" "$args2" ;;
(4) set -- "$args0" "$args1" "$args2" "$args3" ;;
(5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
(6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
(7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
(8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
(9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
esac
fi
# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
function splitJvmOpts() {
JVM_OPTS=("$@")
}
eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
================================================
FILE: gradlew.bat
================================================
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS=
set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto init
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto init
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:init
@rem Get command-line arguments, handling Windowz variants
if not "%OS%" == "Windows_NT" goto win9xME_args
if "%@eval[2+2]" == "4" goto 4NT_args
:win9xME_args
@rem Slurp the command line arguments.
set CMD_LINE_ARGS=
set _SKIP=2
:win9xME_args_slurp
if "x%~1" == "x" goto execute
set CMD_LINE_ARGS=%*
goto execute
:4NT_args
@rem Get arguments from the 4NT Shell from JP Software
set CMD_LINE_ARGS=%$
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
:end
@rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega
================================================
FILE: sample-maven.properties
================================================
bintray_user=user
bintray_apikey=a9a9a9a9a9a9a9a9a9a99a9a9a9a99a9a9
bintray_repo=https://dl.bintray.com/user/maven/
================================================
FILE: settings.gradle
================================================
include ':core', ':sqlite'
================================================
FILE: sqlite/build.gradle
================================================
apply plugin: 'kotlin'
apply from: "${rootProject.rootDir}/bintray.gradle"
sourceSets {
main.kotlin.srcDirs += 'src'
test.kotlin.srcDirs += 'test'
}
dependencies {
compile project(':core')
compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
compile 'junit:junit:4.12'
compile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
}
================================================
FILE: sqlite/src/tel/egram/kuery/sqlite/SQLiteDefinition.kt
================================================
package tel.egram.kuery.sqlite
import tel.egram.kuery.*
import tel.egram.kuery.ddl.*
class SQLiteDefinition(column: Table.Column, val meta: SQLiteDefinition.Meta) : Definition.Column(column, meta.type) {
fun primaryKey(autoIncrement: Boolean = false): SQLiteDefinition {
if (autoIncrement && meta.type != "INTEGER")
throw UnsupportedOperationException("Autoincrement is only supported on INTEGER columns")
return SQLiteDefinition(column, meta.copy(primaryKeyConstraint = PrimaryKeyConstraint(autoIncrement)))
}
fun foreignKey(references: Table.Column): SQLiteDefinition {
return SQLiteDefinition(column, meta.copy(foreignKeyConstraint = ForeignKeyConstraint(references)))
}
fun unique(): SQLiteDefinition {
return SQLiteDefinition(column, meta.copy(uniqueConstraint = UniqueConstraint()))
}
fun notNull(): SQLiteDefinition {
return SQLiteDefinition(column, meta.copy(notNullConstraint = NotNullConstraint()))
}
data class Meta(
val type: String,
val primaryKeyConstraint: PrimaryKeyConstraint? = null,
val foreignKeyConstraint: ForeignKeyConstraint? = null,
val uniqueConstraint: UniqueConstraint? = null,
val notNullConstraint: NotNullConstraint? = null
)
class PrimaryKeyConstraint(val autoIncrement: Boolean = false)
class ForeignKeyConstraint(val references: Table.Column)
class UniqueConstraint
class NotNullConstraint
}
fun integer(column: Table.Column): SQLiteDefinition {
return SQLiteDefinition(column, SQLiteDefinition.Meta(type = "INTEGER"))
}
fun real(column: Table.Column): SQLiteDefinition {
return SQLiteDefinition(column, SQLiteDefinition.Meta(type = "REAL"))
}
fun text(column: Table.Column): SQLiteDefinition {
return SQLiteDefinition(column, SQLiteDefinition.Meta(type = "TEXT"))
}
fun blob(column: Table.Column): SQLiteDefinition {
return SQLiteDefinition(column, SQLiteDefinition.Meta(type = "BLOB"))
}
================================================
FILE: sqlite/src/tel/egram/kuery/sqlite/SQLiteDialect.kt
================================================
package tel.egram.kuery.sqlite
import tel.egram.kuery.*
import tel.egram.kuery.ddl.CreateTableStatement
import tel.egram.kuery.ddl.DropTableStatement
import tel.egram.kuery.dml.*
object SQLiteDialect : Dialect {
override fun <T : Table> build(statement: CreateTableStatement<T>): String {
val builder = StringBuilder()
builder.append("CREATE TABLE ")
appendTableName(builder, statement.subject.table)
builder.append('(')
var delim = ""
for (definition in statement.definitions) {
builder.append(delim)
delim = ", "
appendShortColumnName(builder, definition.column)
builder.append(' ')
builder.append(definition.type)
if (definition is SQLiteDefinition) {
if (definition.meta.primaryKeyConstraint != null) {
builder.append(" PRIMARY KEY")
if (definition.meta.primaryKeyConstraint.autoIncrement) builder.append(" AUTOINCREMENT")
}
if (definition.meta.foreignKeyConstraint != null) {
builder.append(" REFERENCES ")
appendFullColumnName(builder, definition.meta.foreignKeyConstraint.references)
}
if (definition.meta.uniqueConstraint != null) {
builder.append(" UNIQUE")
}
if (definition.meta.notNullConstraint != null) {
builder.append(" NOT NULL")
}
}
}
builder.append(')')
return builder.toString()
}
override fun <T : Table> build(statement: DropTableStatement<T>): String {
return "DROP TABLE \"${statement.subject.table}\""
}
override fun <T : Table> build(statement: SelectStatement<T>): String {
val builder = StringBuilder()
builder.append("SELECT ")
appendProjection(builder, statement.projection, false)
builder.append(" FROM ")
appendTableName(builder, statement.subject.table)
val where = statement.whereClause
if (where != null) {
builder.append(" WHERE ")
appendPredicate(builder, where.predicate, false)
}
val group = statement.groupClause
if (group != null) {
builder.append(" GROUP BY ")
appendProjection(builder, group.projection, false)
}
val having = statement.havingClause
if (having != null) {
builder.append(" HAVING ")
appendPredicate(builder, having.predicate, false)
}
val order = statement.orderClause
if (order != null) {
builder.append(" ORDER BY ")
appendOrdering(builder, order.orderings, false)
}
val limit = statement.limitClause
if (limit != null) {
builder.append(" LIMIT ")
builder.append(limit.limit)
}
val offset = statement.offsetClause
if (offset != null) {
builder.append(" OFFSET ")
builder.append(offset.offset)
}
return builder.toString()
}
override fun <T : Table, T2 : Table> build(statement: Select2Statement<T, T2>): String {
val builder = StringBuilder()
builder.append("SELECT ")
appendProjection(builder, statement.projection, true)
builder.append(" FROM ")
appendTableName(builder, statement.joinOn2Clause.subject.table)
if (statement.joinOn2Clause.type == JoinType.OUTER) builder.append(" OUTER")
builder.append(" JOIN ")
appendTableName(builder, statement.joinOn2Clause.table2)
builder.append(" ON ")
appendPredicate(builder, statement.joinOn2Clause.condition, true)
val where = statement.where2Clause
if (where != null) {
builder.append(" WHERE ")
appendPredicate(builder, where.predicate, true)
}
val group = statement.group2Clause
if (group != null) {
builder.append(" GROUP BY ")
appendProjection(builder, group.projection, true)
}
val having = statement.having2Clause
if (having != null) {
builder.append(" HAVING ")
appendPredicate(builder, having.predicate, true)
}
val order = statement.order2Clause
if (order != null) {
builder.append(" ORDER BY ")
appendOrdering(builder, order.orderings, true)
}
val limit = statement.limit2Clause
if (limit != null) {
builder.append(" LIMIT ")
builder.append(limit.limit)
}
val offset = statement.offset2Clause
if (offset != null) {
builder.append(" OFFSET ")
builder.append(offset.offset)
}
return builder.toString()
}
override fun <T : Table, T2 : Table, T3 : Table> build(statement: Select3Statement<T, T2, T3>): String {
val builder = StringBuilder()
builder.append("SELECT ")
appendProjection(builder, statement.projection, true)
builder.append(" FROM ")
appendTableName(builder, statement.joinOn3Clause.joinOn2Clause.subject.table)
if (statement.joinOn3Clause.joinOn2Clause.type == JoinType.OUTER) builder.append(" OUTER")
builder.append(" JOIN ")
appendTableName(builder, statement.joinOn3Clause.joinOn2Clause.table2)
builder.append(" ON ")
appendPredicate(builder, statement.joinOn3Clause.joinOn2Clause.condition, true)
if (statement.joinOn3Clause.type == JoinType.OUTER) builder.append(" OUTER")
builder.append(" JOIN ")
appendTableName(builder, statement.joinOn3Clause.table3)
builder.append(" ON ")
appendPredicate(builder, statement.joinOn3Clause.condition, true)
val where = statement.where3Clause
if (where != null) {
builder.append(" WHERE ")
appendPredicate(builder, where.predicate, true)
}
val group = statement.group3Clause
if (group != null) {
builder.append(" GROUP BY ")
appendProjection(builder, group.projection, true)
}
val having = statement.having3Clause
if (having != null) {
builder.append(" HAVING ")
appendPredicate(builder, having.predicate, true)
}
val order = statement.order3Clause
if (order != null) {
builder.append(" ORDER BY ")
appendOrdering(builder, order.orderings, true)
}
val limit = statement.limit3Clause
if (limit != null) {
builder.append(" LIMIT ")
builder.append(limit.limit)
}
val offset = statement.offset3Clause
if (offset != null) {
builder.append(" OFFSET ")
builder.append(offset.offset)
}
return builder.toString()
}
override fun <T : Table, T2 : Table, T3 : Table, T4 : Table> build(statement: Select4Statement<T, T2, T3, T4>): String {
val builder = StringBuilder()
builder.append("SELECT ")
appendProjection(builder, statement.projection, true)
builder.append(" FROM ")
appendTableName(builder, statement.joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table)
if (statement.joinOn4Clause.joinOn3Clause.joinOn2Clause.type == JoinType.OUTER) builder.append(" OUTER")
builder.append(" JOIN ")
appendTableName(builder, statement.joinOn4Clause.joinOn3Clause.joinOn2Clause.table2)
builder.append(" ON ")
appendPredicate(builder, statement.joinOn4Clause.joinOn3Clause.joinOn2Clause.condition, true)
if (statement.joinOn4Clause.joinOn3Clause.type == JoinType.OUTER) builder.append(" OUTER")
builder.append(" JOIN ")
appendTableName(builder, statement.joinOn4Clause.joinOn3Clause.table3)
builder.append(" ON ")
appendPredicate(builder, statement.joinOn4Clause.joinOn3Clause.condition, true)
if (statement.joinOn4Clause.type == JoinType.OUTER) builder.append(" OUTER")
builder.append(" JOIN ")
appendTableName(builder, statement.joinOn4Clause.table4)
builder.append(" ON ")
appendPredicate(builder, statement.joinOn4Clause.condition, true)
val where = statement.where4Clause
if (where != null) {
builder.append(" WHERE ")
appendPredicate(builder, where.predicate, true)
}
val group = statement.group4Clause
if (group != null) {
builder.append(" GROUP BY ")
appendProjection(builder, group.projection, true)
}
val having = statement.having4Clause
if (having != null) {
builder.append(" HAVING ")
appendPredicate(builder, having.predicate, true)
}
val order = statement.order4Clause
if (order != null) {
builder.append(" ORDER BY ")
appendOrdering(builder, order.orderings, true)
}
val limit = statement.limit4Clause
if (limit != null) {
builder.append(" LIMIT ")
builder.append(limit.limit)
}
val offset = statement.offset4Clause
if (offset != null) {
builder.append(" OFFSET ")
builder.append(offset.offset)
}
return builder.toString()
}
override fun <T : Table> build(statement: InsertStatement<T>): String {
val builder = StringBuilder()
builder.append("INSERT INTO ")
appendTableName(builder, statement.subject.table)
builder.append(" (")
var delim = ""
for (assign in statement.assignments) {
builder.append(delim)
delim = ", "
appendShortColumnName(builder, assign.column)
}
builder.append(") VALUES (")
delim = ""
for (assign in statement.assignments) {
builder.append(delim)
delim = ", "
appendValue(builder, assign.value)
}
builder.append(")")
return builder.toString()
}
override fun <T : Table> build(statement: UpdateStatement<T>): String {
val builder = StringBuilder()
builder.append("UPDATE ")
appendTableName(builder, statement.subject.table)
builder.append(" SET ")
var delim = ""
for (assign in statement.assignments) {
builder.append(delim)
delim = ", "
appendShortColumnName(builder, assign.column)
builder.append(" = ")
appendValue(builder, assign.value)
}
val where = statement.whereClause
if (where != null) {
builder.append(" WHERE ")
appendPredicate(builder, where.predicate, false)
}
return builder.toString()
}
override fun <T : Table> build(statement: DeleteStatement<T>): String {
val builder = StringBuilder()
builder.append("DELETE FROM ")
appendTableName(builder, statement.subject.table)
val where = statement.whereClause
if (where != null) {
builder.append(" WHERE ")
appendPredicate(builder, where.predicate, false)
}
return builder.toString()
}
private fun appendPredicate(builder: StringBuilder, value: Any?, fullFormat: Boolean = true) {
when (value) {
is Table.Column -> if (fullFormat) appendFullColumnName(builder, value) else appendShortColumnName(builder, value)
is NotExpression -> {
builder.append("(NOT ")
appendPredicate(builder, value.param, fullFormat)
builder.append(")")
}
is AndExpression -> {
builder.append('(')
appendPredicate(builder, value.left, fullFormat)
builder.append(" AND ")
appendPredicate(builder, value.right, fullFormat)
builder.append(')')
}
is OrExpression -> {
builder.append('(')
appendPredicate(builder, value.left, fullFormat)
builder.append(" OR ")
appendPredicate(builder, value.right, fullFormat)
builder.append(')')
}
is EqExpression -> {
builder.append('(')
if (value.right != null) {
appendPredicate(builder, value.left, fullFormat)
builder.append(" = ")
appendPredicate(builder, value.right, fullFormat)
} else {
appendPredicate(builder, value.left, fullFormat)
builder.append(" IS NULL")
}
builder.append(')')
}
is NeExpression -> {
builder.append('(')
if (value.right != null) {
appendPredicate(builder, value.left, fullFormat)
builder.append(" != ")
appendPredicate(builder, value.right, fullFormat)
} else {
appendPredicate(builder, value.left, fullFormat)
builder.append(" IS NOT NULL")
}
builder.append(')')
}
is LtExpression -> {
builder.append('(')
appendPredicate(builder, value.left, fullFormat)
builder.append(" < ")
appendPredicate(builder, value.right, fullFormat)
builder.append(')')
}
is LteExpression -> {
builder.append('(')
appendPredicate(builder, value.left, fullFormat)
builder.append(" <= ")
appendPredicate(builder, value.right, fullFormat)
builder.append(')')
}
is GtExpression -> {
builder.append('(')
appendPredicate(builder, value.left, fullFormat)
builder.append(" > ")
appendPredicate(builder, value.right, fullFormat)
builder.append(')')
}
is GteExpression -> {
builder.append('(')
appendPredicate(builder, value.left, fullFormat)
builder.append(" >= ")
appendPredicate(builder, value.right, fullFormat)
builder.append(')')
}
else -> appendValue(builder, value)
}
}
private fun appendProjection(builder: StringBuilder, projection: Iterable<Projection>, fullFormat: Boolean) {
if ("SELECT".contentEquals(builder.toString().trim()) and projection.none()) {
builder.append("*")
} else {
var delim = ""
for (proj in projection) {
builder.append(delim)
delim = ", "
if (proj is Table.Column) {
if (fullFormat) {
appendFullColumnName(builder, proj)
} else {
appendShortColumnName(builder, proj)
}
} else {
builder.append(proj)
}
}
}
}
private fun appendOrdering(builder: StringBuilder, orderings: Iterable<Ordering>, fullFormat: Boolean) {
var delim = ""
for (order in orderings) {
builder.append(delim)
delim = ", "
if (order.key is Table.Column) {
if (fullFormat) {
appendFullColumnName(builder, order.key as Table.Column)
} else {
appendShortColumnName(builder, order.key as Table.Column)
}
} else {
builder.append(order.key)
}
builder.append(if (order.asc) " ASC" else " DESC")
}
}
private fun appendTableName(builder: StringBuilder, table: Table) {
builder.append("\"$table\"")
}
private fun appendShortColumnName(builder: StringBuilder, column: Table.Column) {
builder.append("\"$column\"")
}
private fun appendFullColumnName(builder: StringBuilder, column: Table.Column) {
builder.append("\"${column.table}\".\"$column\"")
}
private fun appendValue(builder: StringBuilder, value: Any?) {
value?.let {
builder.append((value as? String)?.escapedSQLString() ?: value)
} ?: builder.append("NULL")
}
private fun String.escapedSQLString(): String = "\'${this.replace("'", "''")}\'"
}
================================================
FILE: sqlite/test/tel/egram/kuery/sqlite/tests/SQLiteDialectTest.kt
================================================
package tel.egram.kuery.sqlite.tests
import tel.egram.kuery.*
import tel.egram.kuery.sqlite.*
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.JUnit4
import kotlin.test.assertEquals
@RunWith(JUnit4::class)
class SQLiteDialectTest {
private object TestTable : Table("TestTable") {
val id = Column("id")
val component1 = Column("component1")
val component2 = Column("component2")
}
@Test
fun `test create table`() {
val expected = "CREATE TABLE \"TestTable\"(\"id\" INTEGER PRIMARY KEY AUTOINCREMENT, \"component1\" INTEGER NOT NULL, \"component2\" TEXT NOT NULL)"
val result = over(TestTable)
.create {
integer(TestTable.id).primaryKey(autoIncrement = true)..
integer(TestTable.component1).notNull()..
text(TestTable.component2).notNull()
}.toString(SQLiteDialect)
assertEquals(expected, result)
}
@Test
fun `test where with Strings`() {
val expected = "SELECT \"component1\", \"component2\" FROM \"TestTable\" WHERE ((\"component1\" = 1) AND (\"component2\" = 'TEST'))"
val result = from(TestTable).where { (it.component1 eq 1) and (it.component2 eq "TEST") }.select { it.component1..it.component2 }.toString(SQLiteDialect)
assertEquals(expected, result)
}
@Test
fun `test where with Strings containing single and double quotes`() {
val expectedSingle = "SELECT \"component1\", \"component2\" FROM \"TestTable\" WHERE ((\"component1\" = 1) AND (\"component2\" = 'T''EST'))"
val resultSingle = from(TestTable).where { (it.component1 eq 1) and (it.component2 eq "T'EST") }.select { it.component1..it.component2 }.toString(SQLiteDialect)
assertEquals(expectedSingle, resultSingle)
val expectedDouble = "SELECT \"component1\", \"component2\" FROM \"TestTable\" WHERE ((\"component1\" = 1) AND (\"component2\" = 'T\"EST'))"
val resultDouble = from(TestTable).where { (it.component1 eq 1) and (it.component2 eq "T\"EST") }.select { it.component1..it.component2 }.toString(SQLiteDialect)
assertEquals(expectedDouble, resultDouble)
}
}
gitextract_cz49ip86/
├── .gitignore
├── LICENSE
├── README.md
├── bintray.gradle
├── build.gradle
├── core/
│ ├── build.gradle
│ └── src/
│ └── tel/
│ └── egram/
│ └── kuery/
│ ├── Dialect.kt
│ ├── Predicate.kt
│ ├── Subject.kt
│ ├── Table.kt
│ ├── ddl/
│ │ ├── CreateTableStatement.kt
│ │ ├── Definition.kt
│ │ └── DropTableStatement.kt
│ └── dml/
│ ├── Assignment.kt
│ ├── DeleteStatement.kt
│ ├── GroupClause.kt
│ ├── HavingClause.kt
│ ├── InsertStatement.kt
│ ├── JoinClause.kt
│ ├── LimitClause.kt
│ ├── OffsetClause.kt
│ ├── OrderClause.kt
│ ├── Ordering.kt
│ ├── Projection.kt
│ ├── SelectStatement.kt
│ ├── UpdateStatement.kt
│ └── WhereClause.kt
├── gradle/
│ └── wrapper/
│ ├── gradle-wrapper.jar
│ └── gradle-wrapper.properties
├── gradle.properties
├── gradlew
├── gradlew.bat
├── sample-maven.properties
├── settings.gradle
└── sqlite/
├── build.gradle
├── src/
│ └── tel/
│ └── egram/
│ └── kuery/
│ └── sqlite/
│ ├── SQLiteDefinition.kt
│ └── SQLiteDialect.kt
└── test/
└── tel/
└── egram/
└── kuery/
└── sqlite/
└── tests/
└── SQLiteDialectTest.kt
Condensed preview — 38 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (102K chars).
[
{
"path": ".gitignore",
"chars": 76,
"preview": "build/\n.gradle/\n.idea/\n*.iml\nmaven.properties\nlocal.properties\n.DS_Store\nout"
},
{
"path": "LICENSE",
"chars": 1084,
"preview": "The MIT License (MIT)\n\nCopyright (c) 2016 Sergey Khabibullin\n\nPermission is hereby granted, free of charge, to any perso"
},
{
"path": "README.md",
"chars": 4549,
"preview": "# Kuery - strongly typed SQL in Kotlin\n\nThe library is a strongly typed alternative to plain text SQL. The main goal of "
},
{
"path": "bintray.gradle",
"chars": 2183,
"preview": "apply plugin: 'maven-publish'\napply plugin: 'com.jfrog.bintray'\n\ndefaultTasks 'jar'\n\ntask sourcesJar(type: Jar, dependsO"
},
{
"path": "build.gradle",
"chars": 461,
"preview": "buildscript {\n ext.kotlin_version = '1.2.41'\n\n repositories {\n jcenter()\n mavenCentral()\n }\n d"
},
{
"path": "core/build.gradle",
"chars": 208,
"preview": "apply plugin: 'kotlin'\n\napply from: \"${rootProject.rootDir}/bintray.gradle\"\n\nsourceSets {\n main.kotlin.srcDirs += 'sr"
},
{
"path": "core/src/tel/egram/kuery/Dialect.kt",
"chars": 786,
"preview": "package tel.egram.kuery\n\nimport tel.egram.kuery.ddl.*\nimport tel.egram.kuery.dml.*\n\ninterface Dialect {\n\n fun <T: Tab"
},
{
"path": "core/src/tel/egram/kuery/Predicate.kt",
"chars": 3169,
"preview": "package tel.egram.kuery\n\ninterface Predicate\n\n/**\n * Not expression\n */\nclass NotExpression(val param: Any?) : Predicate"
},
{
"path": "core/src/tel/egram/kuery/Subject.kt",
"chars": 3208,
"preview": "package tel.egram.kuery\n\nimport tel.egram.kuery.ddl.*\nimport tel.egram.kuery.dml.*\n\nopen class Subject<T: Table> {\n\n "
},
{
"path": "core/src/tel/egram/kuery/Table.kt",
"chars": 1812,
"preview": "package tel.egram.kuery\n\nimport tel.egram.kuery.ddl.Definition\nimport tel.egram.kuery.dml.*\n\nopen class Table(private va"
},
{
"path": "core/src/tel/egram/kuery/ddl/CreateTableStatement.kt",
"chars": 263,
"preview": "package tel.egram.kuery.ddl\n\nimport tel.egram.kuery.*\n\nclass CreateTableStatement<T: Table>(\n val definitions: It"
},
{
"path": "core/src/tel/egram/kuery/ddl/Definition.kt",
"chars": 614,
"preview": "package tel.egram.kuery.ddl\n\nimport tel.egram.kuery.*\n\ninterface Definition : Iterable<Definition> {\n\n val column: Ta"
},
{
"path": "core/src/tel/egram/kuery/ddl/DropTableStatement.kt",
"chars": 214,
"preview": "package tel.egram.kuery.ddl\n\nimport tel.egram.kuery.*\n\nclass DropTableStatement<T: Table>(\n val subject: Subject<"
},
{
"path": "core/src/tel/egram/kuery/dml/Assignment.kt",
"chars": 611,
"preview": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.Table\n\ninterface Assignment : Iterable<Assignment> {\n\n val column"
},
{
"path": "core/src/tel/egram/kuery/dml/DeleteStatement.kt",
"chars": 253,
"preview": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass DeleteStatement<T: Table>(\n val subject: Subject<T>,"
},
{
"path": "core/src/tel/egram/kuery/dml/GroupClause.kt",
"chars": 7460,
"preview": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass GroupClause<T: Table>(\n val projection: Iterable<Pro"
},
{
"path": "core/src/tel/egram/kuery/dml/HavingClause.kt",
"chars": 6377,
"preview": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass HavingClause<T: Table>(\n val predicate: Predicate,\n "
},
{
"path": "core/src/tel/egram/kuery/dml/InsertStatement.kt",
"chars": 258,
"preview": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass InsertStatement<T: Table>(\n val assignments: Iterabl"
},
{
"path": "core/src/tel/egram/kuery/dml/JoinClause.kt",
"chars": 7982,
"preview": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass Join2Clause<T: Table, T2: Table>(\n val subject: Subj"
},
{
"path": "core/src/tel/egram/kuery/dml/LimitClause.kt",
"chars": 4433,
"preview": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass LimitClause<T: Table>(\n val limit: Any,\n val "
},
{
"path": "core/src/tel/egram/kuery/dml/OffsetClause.kt",
"chars": 3446,
"preview": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass OffsetClause<T: Table>(\n val offset: Any,\n va"
},
{
"path": "core/src/tel/egram/kuery/dml/OrderClause.kt",
"chars": 5359,
"preview": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass OrderClause<T: Table>(\n val orderings: Iterable<Orde"
},
{
"path": "core/src/tel/egram/kuery/dml/Ordering.kt",
"chars": 543,
"preview": "package tel.egram.kuery.dml\n\ninterface Ordering : Iterable<Ordering> {\n\n val key: Any\n val asc: Boolean\n\n overr"
},
{
"path": "core/src/tel/egram/kuery/dml/Projection.kt",
"chars": 439,
"preview": "package tel.egram.kuery.dml\n\ninterface Projection : Iterable<Projection> {\n override fun iterator(): Iterator<Project"
},
{
"path": "core/src/tel/egram/kuery/dml/SelectStatement.kt",
"chars": 2203,
"preview": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass SelectStatement<T: Table>(\n val projection: Iterable"
},
{
"path": "core/src/tel/egram/kuery/dml/UpdateStatement.kt",
"chars": 300,
"preview": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass UpdateStatement<T: Table>(\n val assignments: Iterabl"
},
{
"path": "core/src/tel/egram/kuery/dml/WhereClause.kt",
"chars": 7456,
"preview": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.Predicate\nimport tel.egram.kuery.Subject\nimport tel.egram.kuery.Tabl"
},
{
"path": "gradle/wrapper/gradle-wrapper.properties",
"chars": 232,
"preview": "#Mon Oct 19 12:09:08 BRST 2015\ndistributionBase=GRADLE_USER_HOME\ndistributionPath=wrapper/dists\nzipStoreBase=GRADLE_USER"
},
{
"path": "gradle.properties",
"chars": 1338,
"preview": "# Project-wide Gradle settings.\n\n# IDE (e.g. Android Studio) users:\n# Gradle settings configured through the IDE *will o"
},
{
"path": "gradlew",
"chars": 5080,
"preview": "#!/usr/bin/env bash\n\n##############################################################################\n##\n## Gradle start "
},
{
"path": "gradlew.bat",
"chars": 2314,
"preview": "@if \"%DEBUG%\" == \"\" @echo off\n@rem ##########################################################################\n@rem\n@rem "
},
{
"path": "sample-maven.properties",
"chars": 115,
"preview": "bintray_user=user\nbintray_apikey=a9a9a9a9a9a9a9a9a9a99a9a9a9a99a9a9\nbintray_repo=https://dl.bintray.com/user/maven/"
},
{
"path": "settings.gradle",
"chars": 26,
"preview": "include ':core', ':sqlite'"
},
{
"path": "sqlite/build.gradle",
"chars": 371,
"preview": "apply plugin: 'kotlin'\n\napply from: \"${rootProject.rootDir}/bintray.gradle\"\n\nsourceSets {\n main.kotlin.srcDirs += 'sr"
},
{
"path": "sqlite/src/tel/egram/kuery/sqlite/SQLiteDefinition.kt",
"chars": 2023,
"preview": "package tel.egram.kuery.sqlite\n\nimport tel.egram.kuery.*\nimport tel.egram.kuery.ddl.*\n\nclass SQLiteDefinition(column: Ta"
},
{
"path": "sqlite/src/tel/egram/kuery/sqlite/SQLiteDialect.kt",
"chars": 16765,
"preview": "package tel.egram.kuery.sqlite\n\nimport tel.egram.kuery.*\nimport tel.egram.kuery.ddl.CreateTableStatement\nimport tel.egra"
},
{
"path": "sqlite/test/tel/egram/kuery/sqlite/tests/SQLiteDialectTest.kt",
"chars": 2236,
"preview": "package tel.egram.kuery.sqlite.tests\n\nimport tel.egram.kuery.*\nimport tel.egram.kuery.sqlite.*\nimport org.junit.Test\nimp"
}
]
// ... and 1 more files (download for full content)
About this extraction
This page contains the full source code of the x2bool/kuery GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 38 files (94.0 KB), approximately 23.4k tokens. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.