[ { "path": ".gitignore", "content": "build/\n.gradle/\n.idea/\n*.iml\nmaven.properties\nlocal.properties\n.DS_Store\nout" }, { "path": "LICENSE", "content": "The MIT License (MIT)\n\nCopyright (c) 2016 Sergey Khabibullin\n\nPermission 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:\n\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n\nTHE 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." }, { "path": "README.md", "content": "# Kuery - strongly typed SQL in Kotlin\n\nThe 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.\n\n## Features\n\n* SQL-like syntax. Use language constructions you already know. Designed to cover the most common SQL features.\n* Strongly typed DSL makes it harder to make mistakes. Some of the most common errors are catched at compile time.\n* IDE's assist in code editing.\n* Easier and safer refactoring/renaming.\n* No reflection\n\n## Foundation\n\nDatabase 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.\n\n```kotlin\nimport tel.egram.kuery.*\n\nobject Organizations : Table(\"organizations\") {\n\tval id = Column(\"id\")\n\tval name = Column(\"name\")\n}\n\nobject Employees : Table(\"employees\") {\n\tval id = Column(\"id\")\n\tval name = Column(\"name\")\n\tval organizationId = Column(\"organization_id\")\n}\n```\n\n**Statements** are the building blocks of the library. A statement usually starts with one of the following function calls:\n* over(table) - used for **CREATE TABLE** and **DROP TABLE** statements\n* into(table) - used for **INSERT** statements\n* from(table) - used for **SELECT**, **UPDATE** and **DELETE** statements\n\n**Dialects** are responsible for converting statements into actual SQL:\n\n```kotlin\nimport tel.egram.kuery.*\nimport tel.egram.kuery.sqlite.*\n\nval statement = from(Employees).where { e -> e.id eq 1 }.select { e -> e.name }\nval sql = statement.toString(SQLiteDialect)\nprint(sql) // SELECT \"name\" FROM \"employees\" WHERE \"id\" = 1\n```\n\n## Data Definition Language\n\nSome parts of data definition language are specific to SQL dialects. An example for SQLite might look like this:\n\n### CREATE TABLE statement\n\n```kotlin\nimport tel.egram.kuery.*\nimport tel.egram.kuery.sqlite.*\n\n// CREATE TABLE \"organizations\" ...\nover(Organizations)\n .create {\n integer(it.id).primaryKey(autoIncrement = true)..\n text(it.name).unique().notNull()\n }\n \n// CREATE TABLE \"employees\" ...\nover(Employees)\n .create {\n integer(it.id).primaryKey(autoIncrement = true)..\n text(it.name).unique().notNull()..\n integer(it.organizationId).foreignKey(references = Organizations.id)\n }\n```\n\n### DROP TABLE statement\n\n```kotlin\n// DROP TABLE \"employees\"\nover(Employees).drop()\n```\n\n## Data Manipulation Language\n\nData manipulation is the most powerfull and complex part of SQL. The library supports **INSERT**, **SELECT**, **UPDATE** and **DELETE** statements.\n\n### INSERT statement\n\n```kotlin\n// INSERT INTO \"employees\"(\"name\", \"organization_id\") VALUES(\"John Doe\", 1)\ninto(Employees)\n .insert { e -> e.name(\"John Doe\") .. e.organizationId(1) }\n```\n\n### SELECT statement\n\nThe library provides the following operators to compose queries:\n* and\n* or\n* not\n* eq (equals)\n* ne (not equals)\n* lt (less than)\n* lte (less than or equal to)\n* gt (greater than)\n* gte (greater than or equal to)\n\n```kotlin\n// SELECT \"id\", \"name\" FROM \"organizations\" WHERE ...\nfrom(Employees)\n .where { e -> (e.organizationId ne null) and (e.name eq \"John Doe\") }\n .groupBy { e -> e.name }\n .having { e -> e.id ne null }\n .orderBy { e -> e.name.asc .. e.id.desc }\n .limit { 10 }\n .offset { 10 }\n .select { e -> e.id .. e.name }\n```\n\n**JOINs** are also supported in select statements\n\n```kotlin\n// SELECT ... FROM \"organizations\" JOIN \"employees\" ON ...\nfrom(Organizations)\n .join(Employees).on { o, e -> o.id eq e.organizationId }\n .select { o, e -> o.name .. e.name }\n```\n\n### UPDATE statement\n\n```kotlin\n// UPDATE \"organizations\" SET \"name\" = 'John Doe' WHERE \"id\" = 1\nfrom(Organizations)\n .where { o -> o.id eq 1 }\n .update { o -> o.name(\"John Doe\") }\n```\n\n### DELETE statement\n```kotlin\n// DELETE FROM \"organizations\" WHERE \"id\" = 0\nfrom(Organizations)\n .where { o -> o.id eq 0 }\n .delete()\n```\n\n## Download\n\nMaven:\n\n```xml\n\n\n tel.egram.kuery\n core\n 0.5.3\n pom\n\n\n\n\n tel.egram.kuery\n sqlite\n 0.5.3\n pom\n\n```\n\nGradle:\n\n```groovy\n// Core library\ncompile 'tel.egram.kuery:core:0.5.3'\n// SQLite dialect\ncompile 'tel.egram.kuery:sqlite:0.5.3'\n```\n" }, { "path": "bintray.gradle", "content": "apply plugin: 'maven-publish'\napply plugin: 'com.jfrog.bintray'\n\ndefaultTasks 'jar'\n\ntask sourcesJar(type: Jar, dependsOn: project.classes) {\n from sourceSets.main.allSource\n}\n\ntask javadocJar(type: Jar, dependsOn: project.javadoc) {\n from javadoc.destinationDir\n}\n\nartifacts {\n archives sourcesJar, javadocJar\n}\n\ndef projDescription = 'Strongly typed alternative to plain text SQL. Powered by Kotlin.'\n\nproject.ext.set(\"bintray_repo\", \"\")\n\nif (file(\"${rootProject.projectDir}/maven.properties\").exists()) {\n Properties properties = new Properties()\n properties.load(new FileInputStream(\"${rootProject.projectDir}/maven.properties\"))\n properties.each { prop ->\n project.ext.set(prop.key, prop.value)\n }\n}\n\npublishing {\n publications {\n \"${project.name}\"(MavenPublication) {\n pom.withXml {\n asNode().appendNode('description', projDescription)\n }\n\n groupId rootProject.group_id\n artifactId project.name\n version rootProject.ext.version_name\n\n artifact sourcesJar { classifier = 'sources' }\n artifact javadocJar { classifier = 'javadoc' }\n\n from components.java\n }\n }\n repositories {\n maven {\n url \"$bintray_repo\"\n }\n maven {\n url \"https://jitpack.io\"\n }\n }\n}\n\nbintray {\n user = project.ext.properties.containsKey(\"bintray_user\") ? project.ext.get(\"bintray_user\") : System.getenv('BINTRAY_USER')\n key = project.ext.properties.containsKey(\"bintray_apikey\") ? project.ext.get(\"bintray_apikey\") : System.getenv('BINTRAY_API_KEY')\n\n publications = [project.name]\n pkg {\n repo = 'maven'\n name = 'kuery'\n userOrg = 'egram'\n licenses = ['MIT']\n vcsUrl = 'https://github.com/x2bool/kuery.git'\n publish = true\n publicDownloadNumbers = true\n version {\n name = rootProject.ext.version_name\n desc = projDescription\n released = new Date()\n vcsTag = rootProject.ext.version_name\n }\n }\n}\n\nbintrayUpload.dependsOn \"generatePomFileFor${project.name.capitalize()}Publication\"" }, { "path": "build.gradle", "content": "buildscript {\n ext.kotlin_version = '1.2.41'\n\n repositories {\n jcenter()\n mavenCentral()\n }\n dependencies {\n classpath \"org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version\"\n classpath \"com.jfrog.bintray.gradle:gradle-bintray-plugin:1+\"\n }\n}\n\next.group_id = 'tel.egram.kuery'\next.version_name = '0.5.3'\n\nallprojects {\n apply plugin: 'maven'\n\n repositories {\n jcenter()\n mavenCentral()\n }\n}\n" }, { "path": "core/build.gradle", "content": "apply plugin: 'kotlin'\n\napply from: \"${rootProject.rootDir}/bintray.gradle\"\n\nsourceSets {\n main.kotlin.srcDirs += 'src'\n}\n\ndependencies {\n compile \"org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version\"\n}\n" }, { "path": "core/src/tel/egram/kuery/Dialect.kt", "content": "package tel.egram.kuery\n\nimport tel.egram.kuery.ddl.*\nimport tel.egram.kuery.dml.*\n\ninterface Dialect {\n\n fun build(statement: CreateTableStatement): String\n fun build(statement: DropTableStatement): String\n\n fun build(statement: SelectStatement): String\n fun build(statement: Select2Statement): String\n fun build(statement: Select3Statement): String\n fun build(statement: Select4Statement): String\n\n fun build(statement: InsertStatement): String\n fun build(statement: UpdateStatement): String\n fun build(statement: DeleteStatement): String\n\n}" }, { "path": "core/src/tel/egram/kuery/Predicate.kt", "content": "package tel.egram.kuery\n\ninterface Predicate\n\n/**\n * Not expression\n */\nclass NotExpression(val param: Any?) : Predicate\n\nfun not(predicate: Predicate): NotExpression {\n return NotExpression(predicate)\n}\n\n/**\n * And expression\n */\nclass AndExpression(val left: Any?, val right: Any?) : Predicate\n\ninfix fun Predicate.and(predicate: Predicate): AndExpression {\n return AndExpression(this, predicate)\n}\n\n/**\n * Or expression\n */\nclass OrExpression(val left: Any?, val right: Any?) : Predicate\n\ninfix fun Predicate.or(predicate: Predicate): OrExpression {\n return OrExpression(this, predicate)\n}\n\n/**\n * Equals expression\n */\nclass EqExpression(val left: Any?, val right: Any?) : Predicate\n\ninfix fun Table.Column.eq(column: Table.Column): EqExpression {\n return EqExpression(this, column)\n}\n\ninfix fun Table.Column.eq(str: String?): EqExpression {\n return EqExpression(this, str)\n}\n\ninfix fun Table.Column.eq(num: Number): EqExpression {\n return EqExpression(this, num)\n}\n\ninfix fun Table.Column.eq(flag: Boolean): EqExpression {\n return EqExpression(this, flag)\n}\n\n/**\n * Not equals expression\n */\nclass NeExpression(val left: Any?, val right: Any?) : Predicate\n\ninfix fun Table.Column.ne(column: Table.Column): NeExpression {\n return NeExpression(this, column)\n}\n\ninfix fun Table.Column.ne(str: String?): NeExpression {\n return NeExpression(this, str)\n}\n\ninfix fun Table.Column.ne(num: Number): NeExpression {\n return NeExpression(this, num)\n}\n\ninfix fun Table.Column.ne(flag: Boolean): NeExpression {\n return NeExpression(this, flag)\n}\n\n/**\n * Less than expression\n */\nclass LtExpression(val left: Any?, val right: Any?) : Predicate\n\ninfix fun Table.Column.lt(column: Table.Column): LtExpression {\n return LtExpression(this, column)\n}\n\ninfix fun Table.Column.lt(str: String?): LtExpression {\n return LtExpression(this, str)\n}\n\ninfix fun Table.Column.lt(num: Number): LtExpression {\n return LtExpression(this, num)\n}\n\n/**\n * Less than or equal expression\n */\nclass LteExpression(val left: Any?, val right: Any?) : Predicate\n\ninfix fun Table.Column.lte(column: Table.Column): LteExpression {\n return LteExpression(this, column)\n}\n\ninfix fun Table.Column.lte(str: String?): LteExpression {\n return LteExpression(this, str)\n}\n\ninfix fun Table.Column.lte(num: Number): LteExpression {\n return LteExpression(this, num)\n}\n\n/**\n * Greater than expression\n */\nclass GtExpression(val left: Any?, val right: Any?) : Predicate\n\ninfix fun Table.Column.gt(column: Table.Column): GtExpression {\n return GtExpression(this, column)\n}\n\ninfix fun Table.Column.gt(str: String?): GtExpression {\n return GtExpression(this, str)\n}\n\ninfix fun Table.Column.gt(num: Number): GtExpression {\n return GtExpression(this, num)\n}\n\n/**\n * Greater than or equal expression\n */\nclass GteExpression(val left: Any?, val right: Any?) : Predicate\n\ninfix fun Table.Column.gte(column: Table.Column): GteExpression {\n return GteExpression(this, column)\n}\n\ninfix fun Table.Column.gte(str: String?): GteExpression {\n return GteExpression(this, str)\n}\n\ninfix fun Table.Column.gte(num: Number): GteExpression {\n return GteExpression(this, num)\n}" }, { "path": "core/src/tel/egram/kuery/Subject.kt", "content": "package tel.egram.kuery\n\nimport tel.egram.kuery.ddl.*\nimport tel.egram.kuery.dml.*\n\nopen class Subject {\n\n val table: T\n\n private constructor(table: T) {\n this.table = table\n }\n\n override fun toString(): String {\n return table.toString()\n }\n\n class Over(table: T) : Subject(table) {\n inline fun create(definition: (T) -> Iterable): CreateTableStatement {\n return CreateTableStatement(definition(table), this)\n }\n\n inline fun drop(): DropTableStatement {\n return DropTableStatement(this)\n }\n }\n\n class From(table: T) : Subject(table) {\n inline fun join(table2: T2): Join2Clause {\n return Join2Clause(this, table2)\n }\n\n inline fun outerJoin(table2: T2): Join2Clause {\n return Join2Clause(this, table2, JoinType.OUTER)\n }\n\n inline fun where(predicate: (T) -> Predicate): WhereClause {\n return WhereClause(predicate(table), this)\n }\n\n inline fun groupBy(projection: (T) -> Iterable): GroupClause {\n return GroupClause(projection(table), this, null)\n }\n\n inline fun orderBy(order: (T) -> Iterable): OrderClause {\n return OrderClause(order(table), this, null, null, null)\n }\n\n inline fun limit(limit: () -> String): LimitClause {\n return LimitClause(\n limit(),\n this,\n null,\n null,\n null,\n null)\n }\n\n inline fun offset(offset: () -> String): OffsetClause {\n return OffsetClause(\n offset(),\n limit { \"-1\" },\n this,\n null,\n null,\n null,\n null)\n }\n\n inline fun select(projection: (T) -> Iterable): SelectStatement {\n return SelectStatement(\n projection(table),\n this,\n null,\n null,\n null,\n null,\n null,\n null)\n }\n\n inline fun update(update: (T) -> Iterable): UpdateStatement {\n return UpdateStatement(\n update(table),\n this,\n null)\n }\n\n inline fun delete(): DeleteStatement {\n return DeleteStatement(\n this,\n null\n )\n }\n }\n\n class Into(table: T) : Subject(table) {\n inline fun insert(insert: (T) -> Iterable): InsertStatement {\n return InsertStatement(insert(table), this)\n }\n }\n}\n\ninline fun over(table: T): Subject.Over {\n return Subject.Over(table)\n}\n\ninline fun from(table: T): Subject.From {\n return Subject.From(table)\n}\n\ninline fun into(table: T): Subject.Into {\n return Subject.Into(table)\n}" }, { "path": "core/src/tel/egram/kuery/Table.kt", "content": "package tel.egram.kuery\n\nimport tel.egram.kuery.ddl.Definition\nimport tel.egram.kuery.dml.*\n\nopen class Table(private val name: String) {\n\n inner class Column(val name: String) : Projection {\n\n val table: Table\n get() = this@Table\n\n val asc: Ordering\n get() = Ordering.By(this, true)\n\n val desc: Ordering\n get() = Ordering.By(this, false)\n\n operator fun invoke(column: Column): Assignment {\n return Assignment.Value(this, column)\n }\n\n operator fun invoke(value: String?): Assignment {\n return Assignment.Value(this, value)\n }\n\n operator fun invoke(value: Number): Assignment {\n return Assignment.Value(this, value)\n }\n\n operator fun invoke(value: Boolean): Assignment {\n return Assignment.Value(this, value)\n }\n\n override fun toString(): String {\n return name\n }\n }\n\n override fun toString(): String {\n return name\n }\n}\n\noperator fun Table.Column.rangeTo(column: Table.Column): Iterable {\n return listOf(this, column)\n}\n\noperator fun Iterable.rangeTo(column: Table.Column): Iterable {\n return this.plusElement(column)\n}\n\noperator fun Iterable.rangeTo(ordering: Ordering): Iterable {\n return if (this is Ordering) listOf(this, ordering) else this.plusElement(ordering)\n}\n\noperator fun Iterable.rangeTo(assignment: Assignment): Iterable {\n return if (this is Assignment) listOf(this, assignment) else this.plusElement(assignment)\n}\n\noperator fun Iterable.rangeTo(definition: Definition): Iterable {\n return if (this is Definition) listOf(this, definition) else this.plusElement(definition)\n}" }, { "path": "core/src/tel/egram/kuery/ddl/CreateTableStatement.kt", "content": "package tel.egram.kuery.ddl\n\nimport tel.egram.kuery.*\n\nclass CreateTableStatement(\n val definitions: Iterable,\n val subject: Subject) {\n\n fun toString(dialect: Dialect): String {\n return dialect.build(this)\n }\n}" }, { "path": "core/src/tel/egram/kuery/ddl/Definition.kt", "content": "package tel.egram.kuery.ddl\n\nimport tel.egram.kuery.*\n\ninterface Definition : Iterable {\n\n val column: Table.Column\n val type: String\n\n override fun iterator(): Iterator {\n return object : Iterator {\n var valid = true\n override fun hasNext(): Boolean {\n return valid\n }\n override fun next(): Definition {\n valid = false\n return this@Definition\n }\n }\n }\n\n open class Column(override val column: Table.Column, override val type: String) : Definition\n}" }, { "path": "core/src/tel/egram/kuery/ddl/DropTableStatement.kt", "content": "package tel.egram.kuery.ddl\n\nimport tel.egram.kuery.*\n\nclass DropTableStatement(\n val subject: Subject) {\n\n fun toString(dialect: Dialect): String {\n return dialect.build(this)\n }\n}" }, { "path": "core/src/tel/egram/kuery/dml/Assignment.kt", "content": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.Table\n\ninterface Assignment : Iterable {\n\n val column: Table.Column\n val value: Any?\n\n override fun iterator(): Iterator {\n return object : Iterator {\n var valid = true\n override fun hasNext(): Boolean {\n return valid\n }\n override fun next(): Assignment {\n valid = false\n return this@Assignment\n }\n }\n }\n\n class Value(override val column: Table.Column, override val value: Any?) : Assignment\n\n}" }, { "path": "core/src/tel/egram/kuery/dml/DeleteStatement.kt", "content": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass DeleteStatement(\n val subject: Subject,\n val whereClause: WhereClause?) {\n\n fun toString(dialect: Dialect): String {\n return dialect.build(this)\n }\n}" }, { "path": "core/src/tel/egram/kuery/dml/GroupClause.kt", "content": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass GroupClause(\n val projection: Iterable,\n val subject: Subject,\n val whereClause: WhereClause?) {\n\n inline fun having(predicate: (T) -> Predicate): HavingClause {\n return HavingClause(predicate(subject.table), subject, this, whereClause)\n }\n\n inline fun orderBy(order: (T) -> Iterable): OrderClause {\n return OrderClause(order(subject.table), subject, whereClause, this, null)\n }\n\n inline fun limit(limit: () -> Any): LimitClause {\n return LimitClause(\n limit(),\n subject,\n whereClause,\n null,\n this,\n null)\n }\n\n inline fun offset(offset: () -> Any): OffsetClause {\n return OffsetClause(\n offset(),\n limit { \"-1\" },\n subject,\n whereClause,\n null,\n this,\n null)\n }\n\n inline fun select(projection: (T) -> Iterable): SelectStatement {\n return SelectStatement(\n projection(subject.table),\n subject,\n whereClause,\n null,\n null,\n null,\n this,\n null\n )\n }\n\n}\n\nclass Group2Clause(\n val projection: Iterable,\n val joinOn2Clause: JoinOn2Clause,\n val where2Clause: Where2Clause?) {\n\n inline fun having(predicate: (T, T2) -> Predicate): Having2Clause {\n return Having2Clause(\n predicate(joinOn2Clause.subject.table, joinOn2Clause.table2),\n joinOn2Clause,\n this,\n where2Clause)\n }\n\n inline fun orderBy(order: (T, T2) -> Iterable): Order2Clause {\n return Order2Clause(order(joinOn2Clause.subject.table, joinOn2Clause.table2), joinOn2Clause, where2Clause, this, null)\n }\n\n inline fun limit(limit: () -> Any): Limit2Clause {\n return Limit2Clause(\n limit(),\n joinOn2Clause,\n where2Clause,\n null,\n this,\n null)\n }\n\n inline fun offset(offset: () -> Any): Offset2Clause {\n return Offset2Clause(\n offset(),\n limit { \"-1\" },\n joinOn2Clause,\n where2Clause,\n null,\n this,\n null)\n }\n\n inline fun select(projection: (T, T2) -> Iterable): Select2Statement {\n return Select2Statement(\n projection(joinOn2Clause.subject.table, joinOn2Clause.table2),\n joinOn2Clause,\n where2Clause,\n null,\n null,\n null,\n this,\n null\n )\n }\n\n}\n\nclass Group3Clause(\n val projection: Iterable,\n val joinOn3Clause: JoinOn3Clause,\n val where3Clause: Where3Clause?) {\n\n inline fun having(predicate: (T, T2, T3) -> Predicate): Having3Clause {\n return Having3Clause(\n predicate(\n joinOn3Clause.joinOn2Clause.subject.table,\n joinOn3Clause.joinOn2Clause.table2,\n joinOn3Clause.table3),\n joinOn3Clause,\n this,\n where3Clause)\n }\n\n inline fun orderBy(order: (T, T2, T3) -> Iterable): Order3Clause {\n return Order3Clause(\n order(joinOn3Clause.joinOn2Clause.subject.table, joinOn3Clause.joinOn2Clause.table2, joinOn3Clause.table3), joinOn3Clause, where3Clause, this, null)\n }\n\n inline fun limit(limit: () -> Any): Limit3Clause {\n return Limit3Clause(\n limit(),\n joinOn3Clause,\n where3Clause,\n null,\n this,\n null)\n }\n\n inline fun offset(offset: () -> Any): Offset3Clause {\n return Offset3Clause(\n offset(),\n limit { \"-1\" },\n joinOn3Clause,\n where3Clause,\n null,\n this,\n null)\n }\n\n inline fun select(projection: (T, T2, T3) -> Iterable): Select3Statement {\n return Select3Statement(\n projection(\n joinOn3Clause.joinOn2Clause.subject.table,\n joinOn3Clause.joinOn2Clause.table2,\n joinOn3Clause.table3\n ),\n joinOn3Clause,\n where3Clause,\n null,\n null,\n null,\n this,\n null\n )\n }\n\n}\n\nclass Group4Clause(\n val projection: Iterable,\n val joinOn4Clause: JoinOn4Clause,\n val where4Clause: Where4Clause?) {\n\n inline fun having(predicate: (T, T2, T3, T4) -> Predicate): Having4Clause {\n return Having4Clause(\n predicate(\n joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,\n joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,\n joinOn4Clause.joinOn3Clause.table3,\n joinOn4Clause.table4),\n joinOn4Clause,\n this,\n where4Clause)\n }\n\n inline fun orderBy(order: (T, T2, T3, T4) -> Iterable): Order4Clause {\n return Order4Clause(\n order(\n joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,\n joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,\n joinOn4Clause.joinOn3Clause.table3,\n joinOn4Clause.table4\n ),\n joinOn4Clause,\n where4Clause,\n this,\n null)\n }\n\n inline fun limit(limit: () -> Any): Limit4Clause {\n return Limit4Clause(\n limit(),\n joinOn4Clause,\n where4Clause,\n null,\n this,\n null)\n }\n\n inline fun offset(offset: () -> Any): Offset4Clause {\n return Offset4Clause(\n offset(),\n limit { \"-1\" },\n joinOn4Clause,\n where4Clause,\n null,\n this,\n null)\n }\n\n inline fun select(projection: (T, T2, T3, T4) -> Iterable): Select4Statement {\n return Select4Statement(\n projection(\n joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,\n joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,\n joinOn4Clause.joinOn3Clause.table3,\n joinOn4Clause.table4\n ),\n joinOn4Clause,\n where4Clause,\n null,\n null,\n null,\n this,\n null\n )\n }\n\n}" }, { "path": "core/src/tel/egram/kuery/dml/HavingClause.kt", "content": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass HavingClause(\n val predicate: Predicate,\n val subject: Subject,\n val groupClause: GroupClause,\n val whereClause: WhereClause?) {\n\n inline fun orderBy(order: (T) -> Iterable): OrderClause {\n return OrderClause(order(subject.table), subject, whereClause, groupClause, this)\n }\n\n inline fun limit(limit: () -> Any): LimitClause {\n return LimitClause(\n limit(),\n subject,\n whereClause,\n null,\n groupClause,\n this)\n }\n\n inline fun offset(offset: () -> Any): OffsetClause {\n return OffsetClause(\n offset(),\n limit { \"-1\" },\n subject,\n whereClause,\n null,\n groupClause,\n this)\n }\n\n inline fun select(projection: (T) -> Iterable): SelectStatement {\n return SelectStatement(\n projection(subject.table),\n subject,\n whereClause,\n null,\n null,\n null,\n groupClause,\n this)\n }\n\n}\n\nclass Having2Clause(\n val predicate: Predicate,\n val joinOn2Clause: JoinOn2Clause,\n val group2Clause: Group2Clause,\n val where2Clause: Where2Clause?) {\n\n inline fun orderBy(order: (T, T2) -> Iterable): Order2Clause {\n return Order2Clause(order(joinOn2Clause.subject.table, joinOn2Clause.table2), joinOn2Clause, where2Clause, group2Clause, this)\n }\n\n inline fun limit(limit: () -> Any): Limit2Clause {\n return Limit2Clause(\n limit(),\n joinOn2Clause,\n where2Clause,\n null,\n group2Clause,\n this)\n }\n\n inline fun offset(offset: () -> Any): Offset2Clause {\n return Offset2Clause(\n offset(),\n limit { \"-1\" },\n joinOn2Clause,\n where2Clause,\n null,\n group2Clause,\n this)\n }\n\n inline fun select(projection: (T, T2) -> Iterable): Select2Statement {\n return Select2Statement(\n projection(joinOn2Clause.subject.table, joinOn2Clause.table2),\n joinOn2Clause,\n where2Clause,\n null,\n null,\n null,\n group2Clause,\n this\n )\n }\n\n}\n\nclass Having3Clause(\n val predicate: Predicate,\n val joinOn3Clause: JoinOn3Clause,\n val group3Clause: Group3Clause,\n val where3Clause: Where3Clause?) {\n\n inline fun orderBy(order: (T, T2, T3) -> Iterable): Order3Clause {\n return Order3Clause(\n order(joinOn3Clause.joinOn2Clause.subject.table, joinOn3Clause.joinOn2Clause.table2, joinOn3Clause.table3), joinOn3Clause, where3Clause, group3Clause, this)\n }\n\n inline fun limit(limit: () -> Any): Limit3Clause {\n return Limit3Clause(\n limit(),\n joinOn3Clause,\n where3Clause,\n null,\n group3Clause,\n this)\n }\n\n inline fun offset(offset: () -> Any): Offset3Clause {\n return Offset3Clause(\n offset(),\n limit { \"-1\" },\n joinOn3Clause,\n where3Clause,\n null,\n group3Clause,\n this)\n }\n\n inline fun select(projection: (T, T2, T3) -> Iterable): Select3Statement {\n return Select3Statement(\n projection(\n joinOn3Clause.joinOn2Clause.subject.table,\n joinOn3Clause.joinOn2Clause.table2,\n joinOn3Clause.table3\n ),\n joinOn3Clause,\n where3Clause,\n null,\n null,\n null,\n group3Clause,\n this\n )\n }\n\n}\n\nclass Having4Clause(\n val predicate: Predicate,\n val joinOn4Clause: JoinOn4Clause,\n val group4Clause: Group4Clause,\n val where4Clause: Where4Clause?) {\n\n inline fun orderBy(order: (T, T2, T3, T4) -> Iterable): Order4Clause {\n return Order4Clause(\n order(\n joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,\n joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,\n joinOn4Clause.joinOn3Clause.table3,\n joinOn4Clause.table4\n ),\n joinOn4Clause,\n where4Clause,\n group4Clause,\n this)\n }\n\n inline fun limit(limit: () -> Any): Limit4Clause {\n return Limit4Clause(\n limit(),\n joinOn4Clause,\n where4Clause,\n null,\n group4Clause,\n this)\n }\n\n inline fun offset(offset: () -> Any): Offset4Clause {\n return Offset4Clause(\n offset(),\n limit { \"-1\" },\n joinOn4Clause,\n where4Clause,\n null,\n group4Clause,\n this)\n }\n\n inline fun select(projection: (T, T2, T3, T4) -> Iterable): Select4Statement {\n return Select4Statement(\n projection(\n joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,\n joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,\n joinOn4Clause.joinOn3Clause.table3,\n joinOn4Clause.table4\n ),\n joinOn4Clause,\n where4Clause,\n null,\n null,\n null,\n group4Clause,\n this\n )\n }\n\n}" }, { "path": "core/src/tel/egram/kuery/dml/InsertStatement.kt", "content": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass InsertStatement(\n val assignments: Iterable,\n val subject: Subject) {\n\n fun toString(dialect: Dialect): String {\n return dialect.build(this)\n }\n}" }, { "path": "core/src/tel/egram/kuery/dml/JoinClause.kt", "content": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass Join2Clause(\n val subject: Subject,\n val table2: T2,\n val type: JoinType = JoinType.INNER) {\n\n inline fun on(condition: (T, T2) -> Predicate): JoinOn2Clause {\n return JoinOn2Clause(\n subject,\n table2,\n type,\n condition(subject.table, table2)\n )\n }\n\n}\n\nclass JoinOn2Clause(\n val subject: Subject,\n val table2: T2,\n val type: JoinType,\n val condition: Predicate) {\n\n inline fun join(table3: T3): Join3Clause {\n return Join3Clause(this, table3)\n }\n\n inline fun outerJoin(table3: T3): Join3Clause {\n return Join3Clause(this, table3, JoinType.OUTER)\n }\n\n inline fun where(predicate: (T, T2) -> Predicate): Where2Clause {\n return Where2Clause(predicate(subject.table, table2), this)\n }\n\n inline fun groupBy(group: (T, T2) -> Iterable): Group2Clause {\n return Group2Clause(group(subject.table, table2), this, null)\n }\n\n inline fun orderBy(order: (T, T2) -> Iterable): Order2Clause {\n return Order2Clause(order(subject.table, table2), this, null, null, null)\n }\n\n inline fun limit(limit: () -> Any): Limit2Clause {\n return Limit2Clause(\n limit(),\n this,\n null,\n null,\n null,\n null)\n }\n\n inline fun offset(offset: () -> String): Offset2Clause {\n return Offset2Clause(\n offset(),\n limit { \"-1\" },\n this,\n null,\n null,\n null,\n null)\n }\n\n inline fun select(projection: (T, T2) -> Iterable): Select2Statement {\n return Select2Statement(\n projection(subject.table, table2),\n this,\n null,\n null,\n null,\n null,\n null,\n null)\n }\n\n}\n\nclass Join3Clause(\n val joinOn2Clause: JoinOn2Clause,\n val table3: T3,\n val type: JoinType = JoinType.INNER) {\n\n inline fun on(condition: (T, T2, T3) -> Predicate): JoinOn3Clause {\n return JoinOn3Clause(\n joinOn2Clause,\n table3,\n type,\n condition(joinOn2Clause.subject.table, joinOn2Clause.table2, table3)\n )\n }\n}\n\nclass JoinOn3Clause(\n val joinOn2Clause: JoinOn2Clause,\n val table3: T3,\n val type: JoinType,\n val condition: Predicate) {\n\n inline fun join(table4: T4): Join4Clause {\n return Join4Clause(this, table4)\n }\n\n inline fun outerJoin(table4: T4): Join4Clause {\n return Join4Clause(this, table4, JoinType.OUTER)\n }\n\n inline fun where(predicate: (T, T2, T3) -> Predicate): Where3Clause {\n return Where3Clause(predicate(joinOn2Clause.subject.table, joinOn2Clause.table2, table3), this)\n }\n\n inline fun groupBy(group: (T, T2, T3) -> Iterable): Group3Clause {\n return Group3Clause(\n group(joinOn2Clause.subject.table, joinOn2Clause.table2, table3),\n this,\n null\n )\n }\n\n inline fun orderBy(order: (T, T2, T3) -> Iterable): Order3Clause {\n return Order3Clause(\n order(joinOn2Clause.subject.table, joinOn2Clause.table2, table3),\n this,\n null,\n null,\n null\n )\n }\n\n inline fun limit(limit: () -> Any): Limit3Clause {\n return Limit3Clause(\n limit(),\n this,\n null,\n null,\n null,\n null)\n }\n\n inline fun offset(offset: () -> String): Offset3Clause {\n return Offset3Clause(\n offset(),\n limit { \"-1\" },\n this,\n null,\n null,\n null,\n null)\n }\n\n inline fun select(projection: (T, T2, T3) -> Iterable): Select3Statement {\n return Select3Statement(\n projection(joinOn2Clause.subject.table, joinOn2Clause.table2, table3),\n this,\n null,\n null,\n null,\n null,\n null,\n null)\n }\n\n}\n\nclass Join4Clause(\n val joinOn3Clause: JoinOn3Clause,\n val table4: T4,\n val type: JoinType = JoinType.INNER) {\n\n inline fun on(condition: (T, T2, T3, T4) -> Predicate): JoinOn4Clause {\n return JoinOn4Clause(\n joinOn3Clause,\n table4,\n type,\n condition(joinOn3Clause.joinOn2Clause.subject.table, joinOn3Clause.joinOn2Clause.table2, joinOn3Clause.table3, table4)\n )\n }\n}\n\nclass JoinOn4Clause(\n val joinOn3Clause: JoinOn3Clause,\n val table4: T4,\n val type: JoinType,\n val condition: Predicate) {\n \n inline fun where(predicate: (T, T2, T3, T4) -> Predicate): Where4Clause {\n return Where4Clause(\n predicate(\n joinOn3Clause.joinOn2Clause.subject.table,\n joinOn3Clause.joinOn2Clause.table2,\n joinOn3Clause.table3,\n table4\n ),\n this)\n }\n\n inline fun groupBy(group: (T, T2, T3, T4) -> Iterable): Group4Clause {\n return Group4Clause(\n group(\n joinOn3Clause.joinOn2Clause.subject.table,\n joinOn3Clause.joinOn2Clause.table2,\n joinOn3Clause.table3,\n table4\n ),\n this,\n null\n )\n }\n\n inline fun orderBy(order: (T, T2, T3, T4) -> Iterable): Order4Clause {\n return Order4Clause(\n order(\n joinOn3Clause.joinOn2Clause.subject.table,\n joinOn3Clause.joinOn2Clause.table2,\n joinOn3Clause.table3,\n table4\n ),\n this,\n null,\n null,\n null\n )\n }\n\n inline fun limit(limit: () -> Any): Limit4Clause {\n return Limit4Clause(\n limit(),\n this,\n null,\n null,\n null,\n null)\n }\n\n inline fun offset(offset: () -> String): Offset4Clause {\n return Offset4Clause(\n offset(),\n limit { \"-1\" },\n this,\n null,\n null,\n null,\n null)\n }\n\n inline fun select(projection: (T, T2, T3, T4) -> Iterable): Select4Statement {\n return Select4Statement(\n projection(\n joinOn3Clause.joinOn2Clause.subject.table,\n joinOn3Clause.joinOn2Clause.table2,\n joinOn3Clause.table3,\n table4\n ),\n this,\n null,\n null,\n null,\n null,\n null,\n null)\n }\n\n}\n\nenum class JoinType {\n INNER,\n OUTER\n}" }, { "path": "core/src/tel/egram/kuery/dml/LimitClause.kt", "content": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass LimitClause(\n val limit: Any,\n val subject: Subject,\n val whereClause: WhereClause?,\n val orderClause: OrderClause?,\n val groupClause: GroupClause?,\n val havingClause: HavingClause?) {\n\n inline fun offset(offset: () -> Any): OffsetClause {\n return OffsetClause(\n offset(),\n this,\n subject,\n whereClause,\n orderClause,\n groupClause,\n havingClause)\n }\n\n inline fun select(projection: (T) -> Iterable): SelectStatement {\n return SelectStatement(\n projection(subject.table),\n subject,\n whereClause,\n orderClause,\n this,\n null,\n groupClause,\n havingClause)\n }\n}\n\nclass Limit2Clause(\n val limit: Any,\n val joinOn2Clause: JoinOn2Clause,\n val where2Clause: Where2Clause?,\n val order2Clause: Order2Clause?,\n val group2Clause: Group2Clause?,\n val having2Clause: Having2Clause?) {\n\n inline fun offset(offset: () -> Any): Offset2Clause {\n return Offset2Clause(\n offset(),\n this,\n joinOn2Clause,\n where2Clause,\n order2Clause,\n group2Clause,\n having2Clause)\n }\n\n inline fun select(projection: (T, T2) -> Iterable): Select2Statement {\n return Select2Statement(\n projection(joinOn2Clause.subject.table, joinOn2Clause.table2),\n joinOn2Clause,\n where2Clause,\n order2Clause,\n this,\n null,\n group2Clause,\n having2Clause)\n }\n\n}\n\nclass Limit3Clause(\n val limit: Any,\n val joinOn3Clause: JoinOn3Clause,\n val where3Clause: Where3Clause?,\n val order3Clause: Order3Clause?,\n val group3Clause: Group3Clause?,\n val having3Clause: Having3Clause?) {\n\n inline fun offset(offset: () -> Any): Offset3Clause {\n return Offset3Clause(\n offset(),\n this,\n joinOn3Clause,\n where3Clause,\n order3Clause,\n group3Clause,\n having3Clause)\n }\n\n inline fun select(projection: (T, T2, T3) -> Iterable): Select3Statement {\n return Select3Statement(\n projection(joinOn3Clause.joinOn2Clause.subject.table, joinOn3Clause.joinOn2Clause.table2, joinOn3Clause.table3),\n joinOn3Clause,\n where3Clause,\n order3Clause,\n this,\n null,\n group3Clause,\n having3Clause)\n }\n}\n\nclass Limit4Clause(\n val limit: Any,\n val joinOn4Clause: JoinOn4Clause,\n val where4Clause: Where4Clause?,\n val order4Clause: Order4Clause?,\n val group4Clause: Group4Clause?,\n val having4Clause: Having4Clause?) {\n\n inline fun offset(offset: () -> Any): Offset4Clause {\n return Offset4Clause(\n offset(),\n this,\n joinOn4Clause,\n where4Clause,\n order4Clause,\n group4Clause,\n having4Clause)\n }\n\n inline fun select(projection: (T, T2, T3, T4) -> Iterable): Select4Statement {\n return Select4Statement(\n projection(\n joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,\n joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,\n joinOn4Clause.joinOn3Clause.table3,\n joinOn4Clause.table4\n ),\n joinOn4Clause,\n where4Clause,\n order4Clause,\n this,\n null,\n group4Clause,\n having4Clause)\n }\n}" }, { "path": "core/src/tel/egram/kuery/dml/OffsetClause.kt", "content": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass OffsetClause(\n val offset: Any,\n val limit: LimitClause,\n val subject: Subject,\n val whereClause: WhereClause?,\n val orderClause: OrderClause?,\n val groupClause: GroupClause?,\n val havingClause: HavingClause?) {\n\n inline fun select(projection: (T) -> Iterable): SelectStatement {\n return SelectStatement(\n projection(subject.table),\n subject,\n whereClause,\n orderClause,\n limit,\n this,\n groupClause,\n havingClause)\n }\n}\n\nclass Offset2Clause(\n val offset: Any,\n val limit2Clause: Limit2Clause,\n val joinOn2Clause: JoinOn2Clause,\n val whereClause: Where2Clause?,\n val orderClause: Order2Clause?,\n val group2Clause: Group2Clause?,\n val having2Clause: Having2Clause?) {\n\n inline fun select(projection: (T, T2) -> Iterable): Select2Statement {\n return Select2Statement(\n projection(joinOn2Clause.subject.table, joinOn2Clause.table2),\n joinOn2Clause,\n whereClause,\n orderClause,\n limit2Clause,\n this,\n group2Clause,\n having2Clause)\n }\n\n}\n\nclass Offset3Clause(\n val offset: Any,\n val limit3Clause: Limit3Clause,\n val joinOn3Clause: JoinOn3Clause,\n val where3Clause: Where3Clause?,\n val order3Clause: Order3Clause?,\n val group3Clause: Group3Clause?,\n val having3Clause: Having3Clause?) {\n\n inline fun select(projection: (T, T2, T3) -> Iterable): Select3Statement {\n return Select3Statement(\n projection(joinOn3Clause.joinOn2Clause.subject.table, joinOn3Clause.joinOn2Clause.table2, joinOn3Clause.table3),\n joinOn3Clause,\n where3Clause,\n order3Clause,\n limit3Clause,\n this,\n group3Clause,\n having3Clause)\n }\n}\n\nclass Offset4Clause(\n val offset: Any,\n val limit4Clause: Limit4Clause,\n val joinOn4Clause: JoinOn4Clause,\n val where4Clause: Where4Clause?,\n val order4Clause: Order4Clause?,\n val group4Clause: Group4Clause?,\n val having4Clause: Having4Clause?) {\n\n inline fun select(projection: (T, T2, T3, T4) -> Iterable): Select4Statement {\n return Select4Statement(\n projection(\n joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,\n joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,\n joinOn4Clause.joinOn3Clause.table3,\n joinOn4Clause.table4\n ),\n joinOn4Clause,\n where4Clause,\n order4Clause,\n limit4Clause,\n this,\n group4Clause,\n having4Clause)\n }\n}" }, { "path": "core/src/tel/egram/kuery/dml/OrderClause.kt", "content": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass OrderClause(\n val orderings: Iterable,\n val subject: Subject,\n val whereClause: WhereClause?,\n val groupClause: GroupClause?,\n val havingClause: HavingClause?) {\n\n inline fun limit(limit: () -> Any): LimitClause {\n return LimitClause(\n limit(),\n subject,\n whereClause,\n this,\n groupClause,\n havingClause)\n }\n\n inline fun offset(offset: () -> Any): OffsetClause {\n return OffsetClause(\n offset(),\n limit { \"-1\" },\n subject,\n whereClause,\n this,\n groupClause,\n havingClause)\n }\n\n inline fun select(projection: (T) -> Iterable): SelectStatement {\n return SelectStatement(\n projection(subject.table),\n subject,\n whereClause,\n this,\n null,\n null,\n groupClause,\n havingClause)\n }\n\n}\n\nclass Order2Clause(\n val orderings: Iterable,\n val joinOn2Clause: JoinOn2Clause,\n val where2Clause: Where2Clause?,\n val group2Clause: Group2Clause?,\n val having2Clause: Having2Clause?) {\n\n inline fun limit(limit: () -> Any): Limit2Clause {\n return Limit2Clause(\n limit(),\n joinOn2Clause,\n where2Clause,\n this,\n group2Clause,\n having2Clause)\n }\n\n inline fun offset(offset: () -> Any): Offset2Clause {\n return Offset2Clause(\n offset(),\n limit { \"-1\" },\n joinOn2Clause,\n where2Clause,\n this,\n group2Clause,\n having2Clause)\n }\n\n inline fun select(projection: (T, T2) -> Iterable): Select2Statement {\n return Select2Statement(\n projection(joinOn2Clause.subject.table, joinOn2Clause.table2),\n joinOn2Clause,\n where2Clause,\n this,\n null,\n null,\n group2Clause,\n having2Clause)\n }\n\n}\n\nclass Order3Clause(\n val orderings: Iterable,\n val joinOn3Clause: JoinOn3Clause,\n val where3Clause: Where3Clause?,\n val group3Clause: Group3Clause?,\n val having3Clause: Having3Clause?) {\n\n inline fun limit(limit: () -> Any): Limit3Clause {\n return Limit3Clause(\n limit(),\n joinOn3Clause,\n where3Clause,\n this,\n group3Clause,\n having3Clause)\n }\n\n inline fun offset(offset: () -> Any): Offset3Clause {\n return Offset3Clause(\n offset(),\n limit { \"-1\" },\n joinOn3Clause,\n where3Clause,\n this,\n group3Clause,\n having3Clause)\n }\n\n inline fun select(projection: (T, T2, T3) -> Iterable): Select3Statement {\n return Select3Statement(\n projection(joinOn3Clause.joinOn2Clause.subject.table, joinOn3Clause.joinOn2Clause.table2, joinOn3Clause.table3),\n joinOn3Clause,\n where3Clause,\n this,\n null,\n null,\n group3Clause,\n having3Clause)\n }\n\n}\n\nclass Order4Clause(\n val orderings: Iterable,\n val joinOn4Clause: JoinOn4Clause,\n val where4Clause: Where4Clause?,\n val group4Clause: Group4Clause?,\n val having4Clause: Having4Clause?) {\n\n inline fun limit(limit: () -> Any): Limit4Clause {\n return Limit4Clause(\n limit(),\n joinOn4Clause,\n where4Clause,\n this,\n group4Clause,\n having4Clause)\n }\n\n inline fun offset(offset: () -> Any): Offset4Clause {\n return Offset4Clause(\n offset(),\n limit { \"-1\" },\n joinOn4Clause,\n where4Clause,\n this,\n group4Clause,\n having4Clause)\n }\n\n inline fun select(projection: (T, T2, T3, T4) -> Iterable): Select4Statement {\n return Select4Statement(\n projection(\n joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,\n joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,\n joinOn4Clause.joinOn3Clause.table3,\n joinOn4Clause.table4\n ),\n joinOn4Clause,\n where4Clause,\n this,\n null,\n null,\n group4Clause,\n having4Clause)\n }\n\n}\n\n" }, { "path": "core/src/tel/egram/kuery/dml/Ordering.kt", "content": "package tel.egram.kuery.dml\n\ninterface Ordering : Iterable {\n\n val key: Any\n val asc: Boolean\n\n override fun iterator(): Iterator {\n return object : Iterator {\n var valid = true\n override fun hasNext(): Boolean {\n return valid\n }\n override fun next(): Ordering {\n valid = false\n return this@Ordering\n }\n }\n }\n\n class By(override val key: Any, override val asc: Boolean) : Ordering\n\n}\n" }, { "path": "core/src/tel/egram/kuery/dml/Projection.kt", "content": "package tel.egram.kuery.dml\n\ninterface Projection : Iterable {\n override fun iterator(): Iterator {\n return object : Iterator {\n var valid = true\n override fun hasNext(): Boolean {\n return valid\n }\n override fun next(): Projection {\n valid = false\n return this@Projection\n }\n }\n }\n}\n" }, { "path": "core/src/tel/egram/kuery/dml/SelectStatement.kt", "content": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass SelectStatement(\n val projection: Iterable,\n val subject: Subject,\n val whereClause: WhereClause?,\n val orderClause: OrderClause?,\n val limitClause: LimitClause?,\n val offsetClause: OffsetClause?,\n val groupClause: GroupClause?,\n val havingClause: HavingClause?) {\n\n fun toString(dialect: Dialect): String {\n return dialect.build(this)\n }\n}\n\nclass Select2Statement(\n val projection: Iterable,\n val joinOn2Clause: JoinOn2Clause,\n val where2Clause: Where2Clause?,\n val order2Clause: Order2Clause?,\n val limit2Clause: Limit2Clause?,\n val offset2Clause: Offset2Clause?,\n val group2Clause: Group2Clause?,\n val having2Clause: Having2Clause?) {\n\n fun toString(dialect: Dialect): String {\n return dialect.build(this)\n }\n}\n\nclass Select3Statement(\n val projection: Iterable,\n val joinOn3Clause: JoinOn3Clause,\n val where3Clause: Where3Clause?,\n val order3Clause: Order3Clause?,\n val limit3Clause: Limit3Clause?,\n val offset3Clause: Offset3Clause?,\n val group3Clause: Group3Clause?,\n val having3Clause: Having3Clause?) {\n\n fun toString(dialect: Dialect): String {\n return dialect.build(this)\n }\n}\n\n\nclass Select4Statement(\n val projection: Iterable,\n val joinOn4Clause: JoinOn4Clause,\n val where4Clause: Where4Clause?,\n val order4Clause: Order4Clause?,\n val limit4Clause: Limit4Clause?,\n val offset4Clause: Offset4Clause?,\n val group4Clause: Group4Clause?,\n val having4Clause: Having4Clause?) {\n\n fun toString(dialect: Dialect): String {\n return dialect.build(this)\n }\n}" }, { "path": "core/src/tel/egram/kuery/dml/UpdateStatement.kt", "content": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.*\n\nclass UpdateStatement(\n val assignments: Iterable,\n val subject: Subject,\n val whereClause: WhereClause?) {\n\n fun toString(dialect: Dialect): String {\n return dialect.build(this)\n }\n}" }, { "path": "core/src/tel/egram/kuery/dml/WhereClause.kt", "content": "package tel.egram.kuery.dml\n\nimport tel.egram.kuery.Predicate\nimport tel.egram.kuery.Subject\nimport tel.egram.kuery.Table\n\nclass WhereClause(\n val predicate: Predicate,\n val subject: Subject) {\n\n inline fun groupBy(group: (T) -> Iterable): GroupClause {\n return GroupClause(group(subject.table), subject, this)\n }\n\n inline fun orderBy(order: (T) -> Iterable): OrderClause {\n return OrderClause(order(subject.table), subject, this, null, null)\n }\n\n inline fun limit(limit: () -> Any): LimitClause {\n return LimitClause(\n limit(),\n subject,\n this,\n null,\n null,\n null)\n }\n\n inline fun offset(offset: () -> Any): OffsetClause {\n return OffsetClause(\n offset(),\n limit { \"-1\" },\n subject,\n this,\n null,\n null,\n null)\n }\n\n inline fun select(projection: (T) -> Iterable): SelectStatement {\n return SelectStatement(\n projection(subject.table),\n subject,\n this,\n null,\n null,\n null,\n null,\n null\n )\n }\n\n inline fun selectAll(): SelectStatement {\n return SelectStatement(\n listOf(),\n subject,\n this,\n null,\n null,\n null,\n null,\n null\n )\n }\n\n inline fun update(value: (T) -> Iterable): UpdateStatement {\n return UpdateStatement(value(subject.table), subject, this)\n }\n\n inline fun delete(): DeleteStatement {\n return DeleteStatement(subject, this)\n }\n}\n\nclass Where2Clause(\n val predicate: Predicate,\n val joinOn2Clause: JoinOn2Clause) {\n\n inline fun groupBy(group: (T, T2) -> Iterable): Group2Clause {\n return Group2Clause(group(joinOn2Clause.subject.table, joinOn2Clause.table2), joinOn2Clause, this)\n }\n\n inline fun orderBy(order: (T, T2) -> Iterable): Order2Clause {\n return Order2Clause(order(joinOn2Clause.subject.table, joinOn2Clause.table2), joinOn2Clause, this, null, null)\n }\n\n inline fun limit(limit: () -> Any): Limit2Clause {\n return Limit2Clause(\n limit(),\n joinOn2Clause,\n this,\n null,\n null,\n null)\n }\n\n inline fun offset(offset: () -> Any): Offset2Clause {\n return Offset2Clause(\n offset(),\n limit { \"-1\" },\n joinOn2Clause,\n this,\n null,\n null,\n null)\n }\n\n inline fun select(projection: (T, T2) -> Iterable): Select2Statement {\n return Select2Statement(\n projection(joinOn2Clause.subject.table, joinOn2Clause.table2),\n joinOn2Clause,\n this,\n null,\n null,\n null,\n null,\n null\n )\n }\n}\n\nclass Where3Clause(\n val predicate: Predicate,\n val joinOn3Clause: JoinOn3Clause) {\n\n inline fun groupBy(group: (T, T2, T3) -> Iterable): Group3Clause {\n return Group3Clause(\n group(joinOn3Clause.joinOn2Clause.subject.table, joinOn3Clause.joinOn2Clause.table2, joinOn3Clause.table3), joinOn3Clause, this)\n }\n\n inline fun orderBy(order: (T, T2, T3) -> Iterable): Order3Clause {\n return Order3Clause(\n order(joinOn3Clause.joinOn2Clause.subject.table, joinOn3Clause.joinOn2Clause.table2, joinOn3Clause.table3), joinOn3Clause, this, null, null)\n }\n\n inline fun limit(limit: () -> Any): Limit3Clause {\n return Limit3Clause(\n limit(),\n joinOn3Clause,\n this,\n null,\n null,\n null)\n }\n\n inline fun offset(offset: () -> Any): Offset3Clause {\n return Offset3Clause(\n offset(),\n limit { \"-1\" },\n joinOn3Clause,\n this,\n null,\n null,\n null)\n }\n\n inline fun select(projection: (T, T2, T3) -> Iterable): Select3Statement {\n return Select3Statement(\n projection(\n joinOn3Clause.joinOn2Clause.subject.table,\n joinOn3Clause.joinOn2Clause.table2,\n joinOn3Clause.table3\n ),\n joinOn3Clause,\n this,\n null,\n null,\n null,\n null,\n null\n )\n }\n}\n\nclass Where4Clause(\n val predicate: Predicate,\n val joinOn4Clause: JoinOn4Clause) {\n\n inline fun groupBy(group: (T, T2, T3, T4) -> Iterable): Group4Clause {\n return Group4Clause(\n group(\n joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,\n joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,\n joinOn4Clause.joinOn3Clause.table3,\n joinOn4Clause.table4\n ),\n joinOn4Clause,\n this)\n }\n\n inline fun orderBy(order: (T, T2, T3, T4) -> Iterable): Order4Clause {\n return Order4Clause(\n order(\n joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,\n joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,\n joinOn4Clause.joinOn3Clause.table3,\n joinOn4Clause.table4\n ),\n joinOn4Clause,\n this,\n null,\n null)\n }\n\n inline fun limit(limit: () -> Any): Limit4Clause {\n return Limit4Clause(\n limit(),\n joinOn4Clause,\n this,\n null,\n null,\n null)\n }\n\n inline fun offset(offset: () -> Any): Offset4Clause {\n return Offset4Clause(\n offset(),\n limit { \"-1\" },\n joinOn4Clause,\n this,\n null,\n null,\n null)\n }\n\n inline fun select(projection: (T, T2, T3, T4) -> Iterable): Select4Statement {\n return Select4Statement(\n projection(\n joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table,\n joinOn4Clause.joinOn3Clause.joinOn2Clause.table2,\n joinOn4Clause.joinOn3Clause.table3,\n joinOn4Clause.table4\n ),\n joinOn4Clause,\n this,\n null,\n null,\n null,\n null,\n null\n )\n }\n}" }, { "path": "gradle/wrapper/gradle-wrapper.properties", "content": "#Mon Oct 19 12:09:08 BRST 2015\ndistributionBase=GRADLE_USER_HOME\ndistributionPath=wrapper/dists\nzipStoreBase=GRADLE_USER_HOME\nzipStorePath=wrapper/dists\ndistributionUrl=https\\://services.gradle.org/distributions/gradle-2.14-all.zip\n" }, { "path": "gradle.properties", "content": "# Project-wide Gradle settings.\n\n# IDE (e.g. Android Studio) users:\n# Gradle settings configured through the IDE *will override*\n# any settings specified in this file.\n\n# For more details on how to configure your build environment visit\n# http://www.gradle.org/docs/current/userguide/build_environment.html\n\n# The Gradle daemon aims to improve the startup and execution time of Gradle.\n# When set to true the Gradle daemon is to run the build.\n# org.gradle.daemon=true\n\n# Specifies the JVM arguments used for the daemon process.\n# The setting is particularly useful for tweaking memory settings.\n# Default value: -Xmx10248m -XX:MaxPermSize=256m\n# org.gradle.jvmargs=-Xmx4096m -XX:MaxPermSize=1024m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8\n\n# When configured, Gradle will run in incubating parallel mode.\n# This option should only be used with decoupled projects. More details, visit\n# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects\n# org.gradle.parallel=true\n\n# Enables new incubating mode that makes Gradle selective when configuring projects.\n# Only relevant projects are configured which results in faster builds for large multi-projects.\n# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:configuration_on_demand\n# org.gradle.configureondemand=true" }, { "path": "gradlew", "content": "#!/usr/bin/env bash\n\n##############################################################################\n##\n## Gradle start up script for UN*X\n##\n##############################################################################\n\n# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.\nDEFAULT_JVM_OPTS=\"\"\n\nAPP_NAME=\"Gradle\"\nAPP_BASE_NAME=`basename \"$0\"`\n\n# Use the maximum available, or set MAX_FD != -1 to use that value.\nMAX_FD=\"maximum\"\n\nwarn ( ) {\n echo \"$*\"\n}\n\ndie ( ) {\n echo\n echo \"$*\"\n echo\n exit 1\n}\n\n# OS specific support (must be 'true' or 'false').\ncygwin=false\nmsys=false\ndarwin=false\ncase \"`uname`\" in\n CYGWIN* )\n cygwin=true\n ;;\n Darwin* )\n darwin=true\n ;;\n MINGW* )\n msys=true\n ;;\nesac\n\n# For Cygwin, ensure paths are in UNIX format before anything is touched.\nif $cygwin ; then\n [ -n \"$JAVA_HOME\" ] && JAVA_HOME=`cygpath --unix \"$JAVA_HOME\"`\nfi\n\n# Attempt to set APP_HOME\n# Resolve links: $0 may be a link\nPRG=\"$0\"\n# Need this for relative symlinks.\nwhile [ -h \"$PRG\" ] ; do\n ls=`ls -ld \"$PRG\"`\n link=`expr \"$ls\" : '.*-> \\(.*\\)$'`\n if expr \"$link\" : '/.*' > /dev/null; then\n PRG=\"$link\"\n else\n PRG=`dirname \"$PRG\"`\"/$link\"\n fi\ndone\nSAVED=\"`pwd`\"\ncd \"`dirname \\\"$PRG\\\"`/\" >&-\nAPP_HOME=\"`pwd -P`\"\ncd \"$SAVED\" >&-\n\nCLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar\n\n# Determine the Java command to use to start the JVM.\nif [ -n \"$JAVA_HOME\" ] ; then\n if [ -x \"$JAVA_HOME/jre/sh/java\" ] ; then\n # IBM's JDK on AIX uses strange locations for the executables\n JAVACMD=\"$JAVA_HOME/jre/sh/java\"\n else\n JAVACMD=\"$JAVA_HOME/bin/java\"\n fi\n if [ ! -x \"$JAVACMD\" ] ; then\n die \"ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\n fi\nelse\n JAVACMD=\"java\"\n which java >/dev/null 2>&1 || die \"ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\nfi\n\n# Increase the maximum file descriptors if we can.\nif [ \"$cygwin\" = \"false\" -a \"$darwin\" = \"false\" ] ; then\n MAX_FD_LIMIT=`ulimit -H -n`\n if [ $? -eq 0 ] ; then\n if [ \"$MAX_FD\" = \"maximum\" -o \"$MAX_FD\" = \"max\" ] ; then\n MAX_FD=\"$MAX_FD_LIMIT\"\n fi\n ulimit -n $MAX_FD\n if [ $? -ne 0 ] ; then\n warn \"Could not set maximum file descriptor limit: $MAX_FD\"\n fi\n else\n warn \"Could not query maximum file descriptor limit: $MAX_FD_LIMIT\"\n fi\nfi\n\n# For Darwin, add options to specify how the application appears in the dock\nif $darwin; then\n GRADLE_OPTS=\"$GRADLE_OPTS \\\"-Xdock:name=$APP_NAME\\\" \\\"-Xdock:icon=$APP_HOME/media/gradle.icns\\\"\"\nfi\n\n# For Cygwin, switch paths to Windows format before running java\nif $cygwin ; then\n APP_HOME=`cygpath --path --mixed \"$APP_HOME\"`\n CLASSPATH=`cygpath --path --mixed \"$CLASSPATH\"`\n\n # We build the pattern for arguments to be converted via cygpath\n ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`\n SEP=\"\"\n for dir in $ROOTDIRSRAW ; do\n ROOTDIRS=\"$ROOTDIRS$SEP$dir\"\n SEP=\"|\"\n done\n OURCYGPATTERN=\"(^($ROOTDIRS))\"\n # Add a user-defined pattern to the cygpath arguments\n if [ \"$GRADLE_CYGPATTERN\" != \"\" ] ; then\n OURCYGPATTERN=\"$OURCYGPATTERN|($GRADLE_CYGPATTERN)\"\n fi\n # Now convert the arguments - kludge to limit ourselves to /bin/sh\n i=0\n for arg in \"$@\" ; do\n CHECK=`echo \"$arg\"|egrep -c \"$OURCYGPATTERN\" -`\n CHECK2=`echo \"$arg\"|egrep -c \"^-\"` ### Determine if an option\n\n if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition\n eval `echo args$i`=`cygpath --path --ignore --mixed \"$arg\"`\n else\n eval `echo args$i`=\"\\\"$arg\\\"\"\n fi\n i=$((i+1))\n done\n case $i in\n (0) set -- ;;\n (1) set -- \"$args0\" ;;\n (2) set -- \"$args0\" \"$args1\" ;;\n (3) set -- \"$args0\" \"$args1\" \"$args2\" ;;\n (4) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" ;;\n (5) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" ;;\n (6) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" ;;\n (7) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" ;;\n (8) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" ;;\n (9) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" \"$args8\" ;;\n esac\nfi\n\n# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules\nfunction splitJvmOpts() {\n JVM_OPTS=(\"$@\")\n}\neval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS\nJVM_OPTS[${#JVM_OPTS[*]}]=\"-Dorg.gradle.appname=$APP_BASE_NAME\"\n\nexec \"$JAVACMD\" \"${JVM_OPTS[@]}\" -classpath \"$CLASSPATH\" org.gradle.wrapper.GradleWrapperMain \"$@\"\n" }, { "path": "gradlew.bat", "content": "@if \"%DEBUG%\" == \"\" @echo off\n@rem ##########################################################################\n@rem\n@rem Gradle startup script for Windows\n@rem\n@rem ##########################################################################\n\n@rem Set local scope for the variables with windows NT shell\nif \"%OS%\"==\"Windows_NT\" setlocal\n\n@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.\nset DEFAULT_JVM_OPTS=\n\nset DIRNAME=%~dp0\nif \"%DIRNAME%\" == \"\" set DIRNAME=.\nset APP_BASE_NAME=%~n0\nset APP_HOME=%DIRNAME%\n\n@rem Find java.exe\nif defined JAVA_HOME goto findJavaFromJavaHome\n\nset JAVA_EXE=java.exe\n%JAVA_EXE% -version >NUL 2>&1\nif \"%ERRORLEVEL%\" == \"0\" goto init\n\necho.\necho ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.\necho.\necho Please set the JAVA_HOME variable in your environment to match the\necho location of your Java installation.\n\ngoto fail\n\n:findJavaFromJavaHome\nset JAVA_HOME=%JAVA_HOME:\"=%\nset JAVA_EXE=%JAVA_HOME%/bin/java.exe\n\nif exist \"%JAVA_EXE%\" goto init\n\necho.\necho ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%\necho.\necho Please set the JAVA_HOME variable in your environment to match the\necho location of your Java installation.\n\ngoto fail\n\n:init\n@rem Get command-line arguments, handling Windowz variants\n\nif not \"%OS%\" == \"Windows_NT\" goto win9xME_args\nif \"%@eval[2+2]\" == \"4\" goto 4NT_args\n\n:win9xME_args\n@rem Slurp the command line arguments.\nset CMD_LINE_ARGS=\nset _SKIP=2\n\n:win9xME_args_slurp\nif \"x%~1\" == \"x\" goto execute\n\nset CMD_LINE_ARGS=%*\ngoto execute\n\n:4NT_args\n@rem Get arguments from the 4NT Shell from JP Software\nset CMD_LINE_ARGS=%$\n\n:execute\n@rem Setup the command line\n\nset CLASSPATH=%APP_HOME%\\gradle\\wrapper\\gradle-wrapper.jar\n\n@rem Execute Gradle\n\"%JAVA_EXE%\" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% \"-Dorg.gradle.appname=%APP_BASE_NAME%\" -classpath \"%CLASSPATH%\" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%\n\n:end\n@rem End local scope for the variables with windows NT shell\nif \"%ERRORLEVEL%\"==\"0\" goto mainEnd\n\n:fail\nrem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of\nrem the _cmd.exe /c_ return code!\nif not \"\" == \"%GRADLE_EXIT_CONSOLE%\" exit 1\nexit /b 1\n\n:mainEnd\nif \"%OS%\"==\"Windows_NT\" endlocal\n\n:omega\n" }, { "path": "sample-maven.properties", "content": "bintray_user=user\nbintray_apikey=a9a9a9a9a9a9a9a9a9a99a9a9a9a99a9a9\nbintray_repo=https://dl.bintray.com/user/maven/" }, { "path": "settings.gradle", "content": "include ':core', ':sqlite'" }, { "path": "sqlite/build.gradle", "content": "apply plugin: 'kotlin'\n\napply from: \"${rootProject.rootDir}/bintray.gradle\"\n\nsourceSets {\n main.kotlin.srcDirs += 'src'\n test.kotlin.srcDirs += 'test'\n}\n\ndependencies {\n compile project(':core')\n compile \"org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version\"\n compile 'junit:junit:4.12'\n compile \"org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version\"\n}\n" }, { "path": "sqlite/src/tel/egram/kuery/sqlite/SQLiteDefinition.kt", "content": "package tel.egram.kuery.sqlite\n\nimport tel.egram.kuery.*\nimport tel.egram.kuery.ddl.*\n\nclass SQLiteDefinition(column: Table.Column, val meta: SQLiteDefinition.Meta) : Definition.Column(column, meta.type) {\n\n fun primaryKey(autoIncrement: Boolean = false): SQLiteDefinition {\n if (autoIncrement && meta.type != \"INTEGER\")\n throw UnsupportedOperationException(\"Autoincrement is only supported on INTEGER columns\")\n\n return SQLiteDefinition(column, meta.copy(primaryKeyConstraint = PrimaryKeyConstraint(autoIncrement)))\n }\n\n fun foreignKey(references: Table.Column): SQLiteDefinition {\n return SQLiteDefinition(column, meta.copy(foreignKeyConstraint = ForeignKeyConstraint(references)))\n }\n\n fun unique(): SQLiteDefinition {\n return SQLiteDefinition(column, meta.copy(uniqueConstraint = UniqueConstraint()))\n }\n\n fun notNull(): SQLiteDefinition {\n return SQLiteDefinition(column, meta.copy(notNullConstraint = NotNullConstraint()))\n }\n\n data class Meta(\n val type: String,\n val primaryKeyConstraint: PrimaryKeyConstraint? = null,\n val foreignKeyConstraint: ForeignKeyConstraint? = null,\n val uniqueConstraint: UniqueConstraint? = null,\n val notNullConstraint: NotNullConstraint? = null\n )\n\n class PrimaryKeyConstraint(val autoIncrement: Boolean = false)\n\n class ForeignKeyConstraint(val references: Table.Column)\n\n class UniqueConstraint\n\n class NotNullConstraint\n}\n\nfun integer(column: Table.Column): SQLiteDefinition {\n return SQLiteDefinition(column, SQLiteDefinition.Meta(type = \"INTEGER\"))\n}\n\nfun real(column: Table.Column): SQLiteDefinition {\n return SQLiteDefinition(column, SQLiteDefinition.Meta(type = \"REAL\"))\n}\n\nfun text(column: Table.Column): SQLiteDefinition {\n return SQLiteDefinition(column, SQLiteDefinition.Meta(type = \"TEXT\"))\n}\n\nfun blob(column: Table.Column): SQLiteDefinition {\n return SQLiteDefinition(column, SQLiteDefinition.Meta(type = \"BLOB\"))\n}" }, { "path": "sqlite/src/tel/egram/kuery/sqlite/SQLiteDialect.kt", "content": "package tel.egram.kuery.sqlite\n\nimport tel.egram.kuery.*\nimport tel.egram.kuery.ddl.CreateTableStatement\nimport tel.egram.kuery.ddl.DropTableStatement\nimport tel.egram.kuery.dml.*\n\nobject SQLiteDialect : Dialect {\n\n override fun build(statement: CreateTableStatement): String {\n val builder = StringBuilder()\n\n builder.append(\"CREATE TABLE \")\n appendTableName(builder, statement.subject.table)\n builder.append('(')\n\n var delim = \"\"\n\n for (definition in statement.definitions) {\n builder.append(delim)\n delim = \", \"\n\n appendShortColumnName(builder, definition.column)\n builder.append(' ')\n builder.append(definition.type)\n\n if (definition is SQLiteDefinition) {\n if (definition.meta.primaryKeyConstraint != null) {\n builder.append(\" PRIMARY KEY\")\n if (definition.meta.primaryKeyConstraint.autoIncrement) builder.append(\" AUTOINCREMENT\")\n }\n\n if (definition.meta.foreignKeyConstraint != null) {\n builder.append(\" REFERENCES \")\n appendFullColumnName(builder, definition.meta.foreignKeyConstraint.references)\n }\n\n if (definition.meta.uniqueConstraint != null) {\n builder.append(\" UNIQUE\")\n }\n\n if (definition.meta.notNullConstraint != null) {\n builder.append(\" NOT NULL\")\n }\n }\n }\n\n builder.append(')')\n\n return builder.toString()\n }\n\n override fun build(statement: DropTableStatement): String {\n return \"DROP TABLE \\\"${statement.subject.table}\\\"\"\n }\n\n override fun build(statement: SelectStatement): String {\n val builder = StringBuilder()\n\n builder.append(\"SELECT \")\n appendProjection(builder, statement.projection, false)\n builder.append(\" FROM \")\n appendTableName(builder, statement.subject.table)\n\n val where = statement.whereClause\n if (where != null) {\n builder.append(\" WHERE \")\n appendPredicate(builder, where.predicate, false)\n }\n\n val group = statement.groupClause\n if (group != null) {\n builder.append(\" GROUP BY \")\n appendProjection(builder, group.projection, false)\n }\n\n val having = statement.havingClause\n if (having != null) {\n builder.append(\" HAVING \")\n appendPredicate(builder, having.predicate, false)\n }\n\n val order = statement.orderClause\n if (order != null) {\n builder.append(\" ORDER BY \")\n appendOrdering(builder, order.orderings, false)\n }\n\n val limit = statement.limitClause\n if (limit != null) {\n builder.append(\" LIMIT \")\n builder.append(limit.limit)\n }\n\n val offset = statement.offsetClause\n if (offset != null) {\n builder.append(\" OFFSET \")\n builder.append(offset.offset)\n }\n\n return builder.toString()\n }\n\n override fun build(statement: Select2Statement): String {\n val builder = StringBuilder()\n\n builder.append(\"SELECT \")\n appendProjection(builder, statement.projection, true)\n builder.append(\" FROM \")\n appendTableName(builder, statement.joinOn2Clause.subject.table)\n\n if (statement.joinOn2Clause.type == JoinType.OUTER) builder.append(\" OUTER\")\n builder.append(\" JOIN \")\n appendTableName(builder, statement.joinOn2Clause.table2)\n builder.append(\" ON \")\n appendPredicate(builder, statement.joinOn2Clause.condition, true)\n\n val where = statement.where2Clause\n if (where != null) {\n builder.append(\" WHERE \")\n appendPredicate(builder, where.predicate, true)\n }\n\n val group = statement.group2Clause\n if (group != null) {\n builder.append(\" GROUP BY \")\n appendProjection(builder, group.projection, true)\n }\n\n val having = statement.having2Clause\n if (having != null) {\n builder.append(\" HAVING \")\n appendPredicate(builder, having.predicate, true)\n }\n\n val order = statement.order2Clause\n if (order != null) {\n builder.append(\" ORDER BY \")\n appendOrdering(builder, order.orderings, true)\n }\n\n val limit = statement.limit2Clause\n if (limit != null) {\n builder.append(\" LIMIT \")\n builder.append(limit.limit)\n }\n\n val offset = statement.offset2Clause\n if (offset != null) {\n builder.append(\" OFFSET \")\n builder.append(offset.offset)\n }\n\n return builder.toString()\n }\n\n override fun build(statement: Select3Statement): String {\n val builder = StringBuilder()\n\n builder.append(\"SELECT \")\n appendProjection(builder, statement.projection, true)\n builder.append(\" FROM \")\n appendTableName(builder, statement.joinOn3Clause.joinOn2Clause.subject.table)\n\n if (statement.joinOn3Clause.joinOn2Clause.type == JoinType.OUTER) builder.append(\" OUTER\")\n builder.append(\" JOIN \")\n appendTableName(builder, statement.joinOn3Clause.joinOn2Clause.table2)\n builder.append(\" ON \")\n appendPredicate(builder, statement.joinOn3Clause.joinOn2Clause.condition, true)\n\n if (statement.joinOn3Clause.type == JoinType.OUTER) builder.append(\" OUTER\")\n builder.append(\" JOIN \")\n appendTableName(builder, statement.joinOn3Clause.table3)\n builder.append(\" ON \")\n appendPredicate(builder, statement.joinOn3Clause.condition, true)\n\n val where = statement.where3Clause\n if (where != null) {\n builder.append(\" WHERE \")\n appendPredicate(builder, where.predicate, true)\n }\n\n val group = statement.group3Clause\n if (group != null) {\n builder.append(\" GROUP BY \")\n appendProjection(builder, group.projection, true)\n }\n\n val having = statement.having3Clause\n if (having != null) {\n builder.append(\" HAVING \")\n appendPredicate(builder, having.predicate, true)\n }\n\n val order = statement.order3Clause\n if (order != null) {\n builder.append(\" ORDER BY \")\n appendOrdering(builder, order.orderings, true)\n }\n\n val limit = statement.limit3Clause\n if (limit != null) {\n builder.append(\" LIMIT \")\n builder.append(limit.limit)\n }\n\n val offset = statement.offset3Clause\n if (offset != null) {\n builder.append(\" OFFSET \")\n builder.append(offset.offset)\n }\n\n return builder.toString()\n }\n\n override fun build(statement: Select4Statement): String {\n val builder = StringBuilder()\n\n builder.append(\"SELECT \")\n appendProjection(builder, statement.projection, true)\n builder.append(\" FROM \")\n appendTableName(builder, statement.joinOn4Clause.joinOn3Clause.joinOn2Clause.subject.table)\n\n if (statement.joinOn4Clause.joinOn3Clause.joinOn2Clause.type == JoinType.OUTER) builder.append(\" OUTER\")\n builder.append(\" JOIN \")\n appendTableName(builder, statement.joinOn4Clause.joinOn3Clause.joinOn2Clause.table2)\n builder.append(\" ON \")\n appendPredicate(builder, statement.joinOn4Clause.joinOn3Clause.joinOn2Clause.condition, true)\n\n if (statement.joinOn4Clause.joinOn3Clause.type == JoinType.OUTER) builder.append(\" OUTER\")\n builder.append(\" JOIN \")\n appendTableName(builder, statement.joinOn4Clause.joinOn3Clause.table3)\n builder.append(\" ON \")\n appendPredicate(builder, statement.joinOn4Clause.joinOn3Clause.condition, true)\n\n if (statement.joinOn4Clause.type == JoinType.OUTER) builder.append(\" OUTER\")\n builder.append(\" JOIN \")\n appendTableName(builder, statement.joinOn4Clause.table4)\n builder.append(\" ON \")\n appendPredicate(builder, statement.joinOn4Clause.condition, true)\n\n val where = statement.where4Clause\n if (where != null) {\n builder.append(\" WHERE \")\n appendPredicate(builder, where.predicate, true)\n }\n\n val group = statement.group4Clause\n if (group != null) {\n builder.append(\" GROUP BY \")\n appendProjection(builder, group.projection, true)\n }\n\n val having = statement.having4Clause\n if (having != null) {\n builder.append(\" HAVING \")\n appendPredicate(builder, having.predicate, true)\n }\n\n val order = statement.order4Clause\n if (order != null) {\n builder.append(\" ORDER BY \")\n appendOrdering(builder, order.orderings, true)\n }\n\n val limit = statement.limit4Clause\n if (limit != null) {\n builder.append(\" LIMIT \")\n builder.append(limit.limit)\n }\n\n val offset = statement.offset4Clause\n if (offset != null) {\n builder.append(\" OFFSET \")\n builder.append(offset.offset)\n }\n\n return builder.toString()\n }\n\n override fun build(statement: InsertStatement): String {\n val builder = StringBuilder()\n builder.append(\"INSERT INTO \")\n appendTableName(builder, statement.subject.table)\n builder.append(\" (\")\n\n var delim = \"\"\n\n for (assign in statement.assignments) {\n builder.append(delim)\n delim = \", \"\n\n appendShortColumnName(builder, assign.column)\n }\n\n builder.append(\") VALUES (\")\n\n delim = \"\"\n\n for (assign in statement.assignments) {\n builder.append(delim)\n delim = \", \"\n\n appendValue(builder, assign.value)\n }\n\n builder.append(\")\")\n\n return builder.toString()\n }\n\n override fun build(statement: UpdateStatement): String {\n val builder = StringBuilder()\n builder.append(\"UPDATE \")\n appendTableName(builder, statement.subject.table)\n builder.append(\" SET \")\n\n var delim = \"\"\n\n for (assign in statement.assignments) {\n builder.append(delim)\n delim = \", \"\n\n appendShortColumnName(builder, assign.column)\n builder.append(\" = \")\n appendValue(builder, assign.value)\n }\n\n val where = statement.whereClause\n if (where != null) {\n builder.append(\" WHERE \")\n appendPredicate(builder, where.predicate, false)\n }\n\n return builder.toString()\n }\n\n override fun build(statement: DeleteStatement): String {\n val builder = StringBuilder()\n builder.append(\"DELETE FROM \")\n appendTableName(builder, statement.subject.table)\n\n val where = statement.whereClause\n if (where != null) {\n builder.append(\" WHERE \")\n appendPredicate(builder, where.predicate, false)\n }\n\n return builder.toString()\n }\n\n private fun appendPredicate(builder: StringBuilder, value: Any?, fullFormat: Boolean = true) {\n when (value) {\n is Table.Column -> if (fullFormat) appendFullColumnName(builder, value) else appendShortColumnName(builder, value)\n\n is NotExpression -> {\n builder.append(\"(NOT \")\n appendPredicate(builder, value.param, fullFormat)\n builder.append(\")\")\n }\n\n is AndExpression -> {\n builder.append('(')\n appendPredicate(builder, value.left, fullFormat)\n builder.append(\" AND \")\n appendPredicate(builder, value.right, fullFormat)\n builder.append(')')\n }\n\n is OrExpression -> {\n builder.append('(')\n appendPredicate(builder, value.left, fullFormat)\n builder.append(\" OR \")\n appendPredicate(builder, value.right, fullFormat)\n builder.append(')')\n }\n\n is EqExpression -> {\n builder.append('(')\n if (value.right != null) {\n appendPredicate(builder, value.left, fullFormat)\n builder.append(\" = \")\n appendPredicate(builder, value.right, fullFormat)\n } else {\n appendPredicate(builder, value.left, fullFormat)\n builder.append(\" IS NULL\")\n }\n builder.append(')')\n }\n\n is NeExpression -> {\n builder.append('(')\n if (value.right != null) {\n appendPredicate(builder, value.left, fullFormat)\n builder.append(\" != \")\n appendPredicate(builder, value.right, fullFormat)\n } else {\n appendPredicate(builder, value.left, fullFormat)\n builder.append(\" IS NOT NULL\")\n }\n builder.append(')')\n }\n\n is LtExpression -> {\n builder.append('(')\n appendPredicate(builder, value.left, fullFormat)\n builder.append(\" < \")\n appendPredicate(builder, value.right, fullFormat)\n builder.append(')')\n }\n\n is LteExpression -> {\n builder.append('(')\n appendPredicate(builder, value.left, fullFormat)\n builder.append(\" <= \")\n appendPredicate(builder, value.right, fullFormat)\n builder.append(')')\n }\n\n is GtExpression -> {\n builder.append('(')\n appendPredicate(builder, value.left, fullFormat)\n builder.append(\" > \")\n appendPredicate(builder, value.right, fullFormat)\n builder.append(')')\n }\n\n is GteExpression -> {\n builder.append('(')\n appendPredicate(builder, value.left, fullFormat)\n builder.append(\" >= \")\n appendPredicate(builder, value.right, fullFormat)\n builder.append(')')\n }\n\n else -> appendValue(builder, value)\n }\n }\n\n private fun appendProjection(builder: StringBuilder, projection: Iterable, fullFormat: Boolean) {\n if (\"SELECT\".contentEquals(builder.toString().trim()) and projection.none()) {\n builder.append(\"*\")\n } else {\n var delim = \"\"\n for (proj in projection) {\n builder.append(delim)\n delim = \", \"\n\n if (proj is Table.Column) {\n if (fullFormat) {\n appendFullColumnName(builder, proj)\n } else {\n appendShortColumnName(builder, proj)\n }\n } else {\n builder.append(proj)\n }\n }\n }\n }\n\n private fun appendOrdering(builder: StringBuilder, orderings: Iterable, fullFormat: Boolean) {\n var delim = \"\"\n\n for (order in orderings) {\n builder.append(delim)\n delim = \", \"\n\n if (order.key is Table.Column) {\n if (fullFormat) {\n appendFullColumnName(builder, order.key as Table.Column)\n } else {\n appendShortColumnName(builder, order.key as Table.Column)\n }\n } else {\n builder.append(order.key)\n }\n\n builder.append(if (order.asc) \" ASC\" else \" DESC\")\n }\n }\n\n private fun appendTableName(builder: StringBuilder, table: Table) {\n builder.append(\"\\\"$table\\\"\")\n }\n\n private fun appendShortColumnName(builder: StringBuilder, column: Table.Column) {\n builder.append(\"\\\"$column\\\"\")\n }\n\n private fun appendFullColumnName(builder: StringBuilder, column: Table.Column) {\n builder.append(\"\\\"${column.table}\\\".\\\"$column\\\"\")\n }\n\n private fun appendValue(builder: StringBuilder, value: Any?) {\n value?.let {\n builder.append((value as? String)?.escapedSQLString() ?: value)\n } ?: builder.append(\"NULL\")\n }\n\n private fun String.escapedSQLString(): String = \"\\'${this.replace(\"'\", \"''\")}\\'\"\n}" }, { "path": "sqlite/test/tel/egram/kuery/sqlite/tests/SQLiteDialectTest.kt", "content": "package tel.egram.kuery.sqlite.tests\n\nimport tel.egram.kuery.*\nimport tel.egram.kuery.sqlite.*\nimport org.junit.Test\nimport org.junit.runner.RunWith\nimport org.junit.runners.JUnit4\nimport kotlin.test.assertEquals\n\n@RunWith(JUnit4::class)\nclass SQLiteDialectTest {\n private object TestTable : Table(\"TestTable\") {\n val id = Column(\"id\")\n val component1 = Column(\"component1\")\n val component2 = Column(\"component2\")\n }\n\n @Test\n fun `test create table`() {\n val expected = \"CREATE TABLE \\\"TestTable\\\"(\\\"id\\\" INTEGER PRIMARY KEY AUTOINCREMENT, \\\"component1\\\" INTEGER NOT NULL, \\\"component2\\\" TEXT NOT NULL)\"\n val result = over(TestTable)\n .create {\n integer(TestTable.id).primaryKey(autoIncrement = true)..\n integer(TestTable.component1).notNull()..\n text(TestTable.component2).notNull()\n }.toString(SQLiteDialect)\n\n assertEquals(expected, result)\n }\n\n @Test\n fun `test where with Strings`() {\n val expected = \"SELECT \\\"component1\\\", \\\"component2\\\" FROM \\\"TestTable\\\" WHERE ((\\\"component1\\\" = 1) AND (\\\"component2\\\" = 'TEST'))\"\n val result = from(TestTable).where { (it.component1 eq 1) and (it.component2 eq \"TEST\") }.select { it.component1..it.component2 }.toString(SQLiteDialect)\n assertEquals(expected, result)\n }\n\n @Test\n fun `test where with Strings containing single and double quotes`() {\n val expectedSingle = \"SELECT \\\"component1\\\", \\\"component2\\\" FROM \\\"TestTable\\\" WHERE ((\\\"component1\\\" = 1) AND (\\\"component2\\\" = 'T''EST'))\"\n val resultSingle = from(TestTable).where { (it.component1 eq 1) and (it.component2 eq \"T'EST\") }.select { it.component1..it.component2 }.toString(SQLiteDialect)\n assertEquals(expectedSingle, resultSingle)\n\n val expectedDouble = \"SELECT \\\"component1\\\", \\\"component2\\\" FROM \\\"TestTable\\\" WHERE ((\\\"component1\\\" = 1) AND (\\\"component2\\\" = 'T\\\"EST'))\"\n val resultDouble = from(TestTable).where { (it.component1 eq 1) and (it.component2 eq \"T\\\"EST\") }.select { it.component1..it.component2 }.toString(SQLiteDialect)\n assertEquals(expectedDouble, resultDouble)\n }\n}" } ]