package org.jooq.meta.sqlite;
import static org.jooq.conf.ParseWithMetaLookups.THROW_ON_FAILURE;
import static org.jooq.impl.DSL.field;
import static org.jooq.impl.DSL.inline;
import static org.jooq.impl.DSL.name;
import static org.jooq.impl.DSL.selectOne;
import static org.jooq.meta.sqlite.sqlite_master.SQLiteMaster.SQLITE_MASTER;
import static org.jooq.tools.StringUtils.isBlank;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.jooq.Configuration;
import org.jooq.Field;
import org.jooq.Record;
import org.jooq.Table;
import org.jooq.TableOptions.TableType;
import org.jooq.impl.DSL;
import org.jooq.meta.AbstractTableDefinition;
import org.jooq.meta.ColumnDefinition;
import org.jooq.meta.DefaultColumnDefinition;
import org.jooq.meta.DefaultDataTypeDefinition;
import org.jooq.meta.SchemaDefinition;
import org.jooq.meta.sqlite.sqlite_master.SQLiteMaster;
public class SQLiteTableDefinition extends AbstractTableDefinition {
private static Boolean existsSqliteSequence;
public SQLiteTableDefinition(SchemaDefinition schema, String name, String comment) {
super(schema, name, comment);
}
public SQLiteTableDefinition(SchemaDefinition schema, String name, String comment, TableType tableType, String source) {
super(schema, name, comment, tableType, source);
}
@Override
public List<ColumnDefinition> getElements0() throws SQLException {
List<ColumnDefinition> result = new ArrayList<>();
Field<String> fName = field(name("name"), String.class);
Field<String> fType = field(name("type"), String.class);
Field<Boolean> fNotnull = field(name("notnull"), boolean.class);
Field<String> fDefaultValue = field(name("dflt_value"), String.class);
Field<Integer> fPk = field(name("pk"), int.class);
Table<?> interpreted = null;
for (Record record : create()
.select(fName, fType, fNotnull, fDefaultValue, fPk)
.from("pragma_table_info({0})", inline(getName()))
) {
String name = record.get(fName);
String dataType = record.get(fType)
.replaceAll("\\(\\d+(\\s*,\\s*\\d+)?\\)", "");
Number precision = parsePrecision(record.get(fType));
Number scale = parseScale(record.get(fType));
int pk = record.get(fPk);
boolean identity = false;
if (isView() && (isBlank(dataType) || "other".equals(dataType))) {
if (interpreted == null) {
try {
Configuration c = create().configuration().derive();
c.settings().withParseWithMetaLookups(THROW_ON_FAILURE);
interpreted = c.dsl().meta(
create().select(SQLiteMaster.SQL)
.from(SQLITE_MASTER)
.where(SQLiteMaster.TBL_NAME.eq(getInputName()))
.fetchOne(SQLiteMaster.SQL)
).getTables(getInputName()).get(0);
}
catch (Exception e) {
throw new RuntimeException("Something went wrong when interpreting the SQL of view " + getInputName());
}
}
Field<?> f = interpreted.field(name);
if (f != null) {
dataType = f.getDataType().getName();
precision = f.getDataType().precision();
scale = f.getDataType().scale();
}
}
if (pk > 0) {
identity |= existsSqliteSequence() && create()
.fetchOne("select count(*) from sqlite_sequence where name = ?", getName())
.get(0, Boolean.class);
if (!identity && !create().fetchExists(selectOne().from("{0}", DSL.name(getName()))))
identity = create()
.select(SQLiteMaster.SQL)
.from(SQLITE_MASTER)
.where(SQLiteMaster.NAME.eq(getName()))
.fetchOneInto(String.class)
.matches("(?s:.*\\b" + getName() + "\\b[^,]*(?i:\\bautoincrement\\b)[^,]*.*)");
}
DefaultDataTypeDefinition type = new DefaultDataTypeDefinition(
getDatabase(),
getSchema(),
dataType,
precision,
precision,
scale,
!record.get(fNotnull),
record.get(fDefaultValue)
);
result.add(new DefaultColumnDefinition(
getDatabase().getTable(getSchema(), getName()),
name,
result.size() + 1,
type,
identity,
null
));
}
return result;
}
private boolean existsSqliteSequence() {
if (existsSqliteSequence == null) {
existsSqliteSequence = create()
.selectCount()
.from(SQLITE_MASTER)
.where(SQLiteMaster.NAME.lower().eq("sqlite_sequence"))
.fetchOne(0, boolean.class);
}
return existsSqliteSequence;
}
}