repo stringlengths 7 58 | path stringlengths 12 218 | func_name stringlengths 3 140 | original_string stringlengths 73 34.1k | language stringclasses 1 value | code stringlengths 73 34.1k | code_tokens list | docstring stringlengths 3 16k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 105 339 | partition stringclasses 1 value |
|---|---|---|---|---|---|---|---|---|---|---|---|
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/Where.java | Where.raw | public Where<T, ID> raw(String rawStatement, ArgumentHolder... args) {
for (ArgumentHolder arg : args) {
String columnName = arg.getColumnName();
if (columnName == null) {
if (arg.getSqlType() == null) {
throw new IllegalArgumentException("Either the column name or SqlType must be set on each argument");
}
} else {
arg.setMetaInfo(findColumnFieldType(columnName));
}
}
addClause(new Raw(rawStatement, args));
return this;
} | java | public Where<T, ID> raw(String rawStatement, ArgumentHolder... args) {
for (ArgumentHolder arg : args) {
String columnName = arg.getColumnName();
if (columnName == null) {
if (arg.getSqlType() == null) {
throw new IllegalArgumentException("Either the column name or SqlType must be set on each argument");
}
} else {
arg.setMetaInfo(findColumnFieldType(columnName));
}
}
addClause(new Raw(rawStatement, args));
return this;
} | [
"public",
"Where",
"<",
"T",
",",
"ID",
">",
"raw",
"(",
"String",
"rawStatement",
",",
"ArgumentHolder",
"...",
"args",
")",
"{",
"for",
"(",
"ArgumentHolder",
"arg",
":",
"args",
")",
"{",
"String",
"columnName",
"=",
"arg",
".",
"getColumnName",
"(",
... | Add a raw statement as part of the where that can be anything that the database supports. Using more structured
methods is recommended but this gives more control over the query and allows you to utilize database specific
features.
@param rawStatement
The statement that we should insert into the WHERE.
@param args
Optional arguments that correspond to any ? specified in the rawStatement. Each of the arguments must
have either the corresponding columnName or the sql-type set. <b>WARNING,</b> you cannot use the
{@code SelectArg("columnName")} constructor since that sets the _value_, not the name. Use
{@code new SelectArg("column-name", null);}. | [
"Add",
"a",
"raw",
"statement",
"as",
"part",
"of",
"the",
"where",
"that",
"can",
"be",
"anything",
"that",
"the",
"database",
"supports",
".",
"Using",
"more",
"structured",
"methods",
"is",
"recommended",
"but",
"this",
"gives",
"more",
"control",
"over",... | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/Where.java#L445-L458 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/Where.java | Where.rawComparison | public Where<T, ID> rawComparison(String columnName, String rawOperator, Object value) throws SQLException {
addClause(new SimpleComparison(columnName, findColumnFieldType(columnName), value, rawOperator));
return this;
} | java | public Where<T, ID> rawComparison(String columnName, String rawOperator, Object value) throws SQLException {
addClause(new SimpleComparison(columnName, findColumnFieldType(columnName), value, rawOperator));
return this;
} | [
"public",
"Where",
"<",
"T",
",",
"ID",
">",
"rawComparison",
"(",
"String",
"columnName",
",",
"String",
"rawOperator",
",",
"Object",
"value",
")",
"throws",
"SQLException",
"{",
"addClause",
"(",
"new",
"SimpleComparison",
"(",
"columnName",
",",
"findColum... | Make a comparison where the operator is specified by the caller. It is up to the caller to specify an appropriate
operator for the database and that it be formatted correctly. | [
"Make",
"a",
"comparison",
"where",
"the",
"operator",
"is",
"specified",
"by",
"the",
"caller",
".",
"It",
"is",
"up",
"to",
"the",
"caller",
"to",
"specify",
"an",
"appropriate",
"operator",
"for",
"the",
"database",
"and",
"that",
"it",
"be",
"formatted... | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/Where.java#L464-L467 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/Where.java | Where.reset | public Where<T, ID> reset() {
for (int i = 0; i < clauseStackLevel; i++) {
// help with gc
clauseStack[i] = null;
}
clauseStackLevel = 0;
return this;
} | java | public Where<T, ID> reset() {
for (int i = 0; i < clauseStackLevel; i++) {
// help with gc
clauseStack[i] = null;
}
clauseStackLevel = 0;
return this;
} | [
"public",
"Where",
"<",
"T",
",",
"ID",
">",
"reset",
"(",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"clauseStackLevel",
";",
"i",
"++",
")",
"{",
"// help with gc",
"clauseStack",
"[",
"i",
"]",
"=",
"null",
";",
"}",
"clauseSta... | Reset the Where object so it can be re-used. | [
"Reset",
"the",
"Where",
"object",
"so",
"it",
"can",
"be",
"re",
"-",
"used",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/Where.java#L521-L528 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/Where.java | Where.getStatement | public String getStatement() throws SQLException {
StringBuilder sb = new StringBuilder();
appendSql(null, sb, new ArrayList<ArgumentHolder>());
return sb.toString();
} | java | public String getStatement() throws SQLException {
StringBuilder sb = new StringBuilder();
appendSql(null, sb, new ArrayList<ArgumentHolder>());
return sb.toString();
} | [
"public",
"String",
"getStatement",
"(",
")",
"throws",
"SQLException",
"{",
"StringBuilder",
"sb",
"=",
"new",
"StringBuilder",
"(",
")",
";",
"appendSql",
"(",
"null",
",",
"sb",
",",
"new",
"ArrayList",
"<",
"ArgumentHolder",
">",
"(",
")",
")",
";",
... | Returns the associated SQL WHERE statement. | [
"Returns",
"the",
"associated",
"SQL",
"WHERE",
"statement",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/Where.java#L533-L537 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/mapped/MappedUpdateId.java | MappedUpdateId.execute | public int execute(DatabaseConnection databaseConnection, T data, ID newId, ObjectCache objectCache)
throws SQLException {
try {
// the arguments are the new-id and old-id
Object[] args = new Object[] { convertIdToFieldObject(newId), extractIdToFieldObject(data) };
int rowC = databaseConnection.update(statement, args, argFieldTypes);
if (rowC > 0) {
if (objectCache != null) {
Object oldId = idField.extractJavaFieldValue(data);
T obj = objectCache.updateId(clazz, oldId, newId);
if (obj != null && obj != data) {
// if our cached value is not the data that will be updated then we need to update it specially
idField.assignField(connectionSource, obj, newId, false, objectCache);
}
}
// adjust the object to assign the new id
idField.assignField(connectionSource, data, newId, false, objectCache);
}
logger.debug("updating-id with statement '{}' and {} args, changed {} rows", statement, args.length, rowC);
if (args.length > 0) {
// need to do the cast otherwise we only print the first object in args
logger.trace("updating-id arguments: {}", (Object) args);
}
return rowC;
} catch (SQLException e) {
throw SqlExceptionUtil.create("Unable to run update-id stmt on object " + data + ": " + statement, e);
}
} | java | public int execute(DatabaseConnection databaseConnection, T data, ID newId, ObjectCache objectCache)
throws SQLException {
try {
// the arguments are the new-id and old-id
Object[] args = new Object[] { convertIdToFieldObject(newId), extractIdToFieldObject(data) };
int rowC = databaseConnection.update(statement, args, argFieldTypes);
if (rowC > 0) {
if (objectCache != null) {
Object oldId = idField.extractJavaFieldValue(data);
T obj = objectCache.updateId(clazz, oldId, newId);
if (obj != null && obj != data) {
// if our cached value is not the data that will be updated then we need to update it specially
idField.assignField(connectionSource, obj, newId, false, objectCache);
}
}
// adjust the object to assign the new id
idField.assignField(connectionSource, data, newId, false, objectCache);
}
logger.debug("updating-id with statement '{}' and {} args, changed {} rows", statement, args.length, rowC);
if (args.length > 0) {
// need to do the cast otherwise we only print the first object in args
logger.trace("updating-id arguments: {}", (Object) args);
}
return rowC;
} catch (SQLException e) {
throw SqlExceptionUtil.create("Unable to run update-id stmt on object " + data + ": " + statement, e);
}
} | [
"public",
"int",
"execute",
"(",
"DatabaseConnection",
"databaseConnection",
",",
"T",
"data",
",",
"ID",
"newId",
",",
"ObjectCache",
"objectCache",
")",
"throws",
"SQLException",
"{",
"try",
"{",
"// the arguments are the new-id and old-id",
"Object",
"[",
"]",
"a... | Update the id field of the object in the database. | [
"Update",
"the",
"id",
"field",
"of",
"the",
"object",
"in",
"the",
"database",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/mapped/MappedUpdateId.java#L27-L54 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/DatabaseFieldConfigLoader.java | DatabaseFieldConfigLoader.fromReader | public static DatabaseFieldConfig fromReader(BufferedReader reader) throws SQLException {
DatabaseFieldConfig config = new DatabaseFieldConfig();
boolean anything = false;
while (true) {
String line;
try {
line = reader.readLine();
} catch (IOException e) {
throw SqlExceptionUtil.create("Could not read DatabaseFieldConfig from stream", e);
}
if (line == null) {
break;
}
// we do this so we can support multiple class configs per file
if (line.equals(CONFIG_FILE_END_MARKER)) {
break;
}
// skip empty lines or comments
if (line.length() == 0 || line.startsWith("#") || line.equals(CONFIG_FILE_START_MARKER)) {
continue;
}
String[] parts = line.split("=", -2);
if (parts.length != 2) {
throw new SQLException("DatabaseFieldConfig reading from stream cannot parse line: " + line);
}
readField(config, parts[0], parts[1]);
anything = true;
}
// if we got any config lines then we return the config
if (anything) {
return config;
} else {
// otherwise we return null for none
return null;
}
} | java | public static DatabaseFieldConfig fromReader(BufferedReader reader) throws SQLException {
DatabaseFieldConfig config = new DatabaseFieldConfig();
boolean anything = false;
while (true) {
String line;
try {
line = reader.readLine();
} catch (IOException e) {
throw SqlExceptionUtil.create("Could not read DatabaseFieldConfig from stream", e);
}
if (line == null) {
break;
}
// we do this so we can support multiple class configs per file
if (line.equals(CONFIG_FILE_END_MARKER)) {
break;
}
// skip empty lines or comments
if (line.length() == 0 || line.startsWith("#") || line.equals(CONFIG_FILE_START_MARKER)) {
continue;
}
String[] parts = line.split("=", -2);
if (parts.length != 2) {
throw new SQLException("DatabaseFieldConfig reading from stream cannot parse line: " + line);
}
readField(config, parts[0], parts[1]);
anything = true;
}
// if we got any config lines then we return the config
if (anything) {
return config;
} else {
// otherwise we return null for none
return null;
}
} | [
"public",
"static",
"DatabaseFieldConfig",
"fromReader",
"(",
"BufferedReader",
"reader",
")",
"throws",
"SQLException",
"{",
"DatabaseFieldConfig",
"config",
"=",
"new",
"DatabaseFieldConfig",
"(",
")",
";",
"boolean",
"anything",
"=",
"false",
";",
"while",
"(",
... | Load a configuration in from a text file.
@return A config if any of the fields were set otherwise null on EOF. | [
"Load",
"a",
"configuration",
"in",
"from",
"a",
"text",
"file",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/DatabaseFieldConfigLoader.java#L30-L65 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/DatabaseFieldConfigLoader.java | DatabaseFieldConfigLoader.write | public static void write(BufferedWriter writer, DatabaseFieldConfig config, String tableName) throws SQLException {
try {
writeConfig(writer, config, tableName);
} catch (IOException e) {
throw SqlExceptionUtil.create("Could not write config to writer", e);
}
} | java | public static void write(BufferedWriter writer, DatabaseFieldConfig config, String tableName) throws SQLException {
try {
writeConfig(writer, config, tableName);
} catch (IOException e) {
throw SqlExceptionUtil.create("Could not write config to writer", e);
}
} | [
"public",
"static",
"void",
"write",
"(",
"BufferedWriter",
"writer",
",",
"DatabaseFieldConfig",
"config",
",",
"String",
"tableName",
")",
"throws",
"SQLException",
"{",
"try",
"{",
"writeConfig",
"(",
"writer",
",",
"config",
",",
"tableName",
")",
";",
"}"... | Write the configuration to a buffered writer. | [
"Write",
"the",
"configuration",
"to",
"a",
"buffered",
"writer",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/DatabaseFieldConfigLoader.java#L70-L76 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/UpdateBuilder.java | UpdateBuilder.updateColumnValue | public UpdateBuilder<T, ID> updateColumnValue(String columnName, Object value) throws SQLException {
FieldType fieldType = verifyColumnName(columnName);
if (fieldType.isForeignCollection()) {
throw new SQLException("Can't update foreign colletion field: " + columnName);
}
addUpdateColumnToList(columnName, new SetValue(columnName, fieldType, value));
return this;
} | java | public UpdateBuilder<T, ID> updateColumnValue(String columnName, Object value) throws SQLException {
FieldType fieldType = verifyColumnName(columnName);
if (fieldType.isForeignCollection()) {
throw new SQLException("Can't update foreign colletion field: " + columnName);
}
addUpdateColumnToList(columnName, new SetValue(columnName, fieldType, value));
return this;
} | [
"public",
"UpdateBuilder",
"<",
"T",
",",
"ID",
">",
"updateColumnValue",
"(",
"String",
"columnName",
",",
"Object",
"value",
")",
"throws",
"SQLException",
"{",
"FieldType",
"fieldType",
"=",
"verifyColumnName",
"(",
"columnName",
")",
";",
"if",
"(",
"field... | Add a column to be set to a value for UPDATE statements. This will generate something like columnName = 'value'
with the value escaped if necessary. | [
"Add",
"a",
"column",
"to",
"be",
"set",
"to",
"a",
"value",
"for",
"UPDATE",
"statements",
".",
"This",
"will",
"generate",
"something",
"like",
"columnName",
"=",
"value",
"with",
"the",
"value",
"escaped",
"if",
"necessary",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/UpdateBuilder.java#L46-L53 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/UpdateBuilder.java | UpdateBuilder.updateColumnExpression | public UpdateBuilder<T, ID> updateColumnExpression(String columnName, String expression) throws SQLException {
FieldType fieldType = verifyColumnName(columnName);
if (fieldType.isForeignCollection()) {
throw new SQLException("Can't update foreign colletion field: " + columnName);
}
addUpdateColumnToList(columnName, new SetExpression(columnName, fieldType, expression));
return this;
} | java | public UpdateBuilder<T, ID> updateColumnExpression(String columnName, String expression) throws SQLException {
FieldType fieldType = verifyColumnName(columnName);
if (fieldType.isForeignCollection()) {
throw new SQLException("Can't update foreign colletion field: " + columnName);
}
addUpdateColumnToList(columnName, new SetExpression(columnName, fieldType, expression));
return this;
} | [
"public",
"UpdateBuilder",
"<",
"T",
",",
"ID",
">",
"updateColumnExpression",
"(",
"String",
"columnName",
",",
"String",
"expression",
")",
"throws",
"SQLException",
"{",
"FieldType",
"fieldType",
"=",
"verifyColumnName",
"(",
"columnName",
")",
";",
"if",
"("... | Add a column to be set to a value for UPDATE statements. This will generate something like 'columnName =
expression' where the expression is built by the caller.
<p>
The expression should have any strings escaped using the {@link #escapeValue(String)} or
{@link #escapeValue(StringBuilder, String)} methods and should have any column names escaped using the
{@link #escapeColumnName(String)} or {@link #escapeColumnName(StringBuilder, String)} methods.
</p> | [
"Add",
"a",
"column",
"to",
"be",
"set",
"to",
"a",
"value",
"for",
"UPDATE",
"statements",
".",
"This",
"will",
"generate",
"something",
"like",
"columnName",
"=",
"expression",
"where",
"the",
"expression",
"is",
"built",
"by",
"the",
"caller",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/UpdateBuilder.java#L65-L72 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/DatabaseTableConfig.java | DatabaseTableConfig.initialize | public void initialize() {
if (dataClass == null) {
throw new IllegalStateException("dataClass was never set on " + getClass().getSimpleName());
}
if (tableName == null) {
tableName = extractTableName(databaseType, dataClass);
}
} | java | public void initialize() {
if (dataClass == null) {
throw new IllegalStateException("dataClass was never set on " + getClass().getSimpleName());
}
if (tableName == null) {
tableName = extractTableName(databaseType, dataClass);
}
} | [
"public",
"void",
"initialize",
"(",
")",
"{",
"if",
"(",
"dataClass",
"==",
"null",
")",
"{",
"throw",
"new",
"IllegalStateException",
"(",
"\"dataClass was never set on \"",
"+",
"getClass",
"(",
")",
".",
"getSimpleName",
"(",
")",
")",
";",
"}",
"if",
... | Initialize the class if this is being called with Spring. | [
"Initialize",
"the",
"class",
"if",
"this",
"is",
"being",
"called",
"with",
"Spring",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/DatabaseTableConfig.java#L80-L87 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/DatabaseTableConfig.java | DatabaseTableConfig.extractFieldTypes | public void extractFieldTypes(DatabaseType databaseType) throws SQLException {
if (fieldTypes == null) {
if (fieldConfigs == null) {
fieldTypes = extractFieldTypes(databaseType, dataClass, tableName);
} else {
fieldTypes = convertFieldConfigs(databaseType, tableName, fieldConfigs);
}
}
} | java | public void extractFieldTypes(DatabaseType databaseType) throws SQLException {
if (fieldTypes == null) {
if (fieldConfigs == null) {
fieldTypes = extractFieldTypes(databaseType, dataClass, tableName);
} else {
fieldTypes = convertFieldConfigs(databaseType, tableName, fieldConfigs);
}
}
} | [
"public",
"void",
"extractFieldTypes",
"(",
"DatabaseType",
"databaseType",
")",
"throws",
"SQLException",
"{",
"if",
"(",
"fieldTypes",
"==",
"null",
")",
"{",
"if",
"(",
"fieldConfigs",
"==",
"null",
")",
"{",
"fieldTypes",
"=",
"extractFieldTypes",
"(",
"da... | Extract the field types from the fieldConfigs if they have not already been configured. | [
"Extract",
"the",
"field",
"types",
"from",
"the",
"fieldConfigs",
"if",
"they",
"have",
"not",
"already",
"been",
"configured",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/DatabaseTableConfig.java#L123-L131 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/DatabaseTableConfig.java | DatabaseTableConfig.fromClass | public static <T> DatabaseTableConfig<T> fromClass(DatabaseType databaseType, Class<T> clazz) throws SQLException {
String tableName = extractTableName(databaseType, clazz);
if (databaseType.isEntityNamesMustBeUpCase()) {
tableName = databaseType.upCaseEntityName(tableName);
}
return new DatabaseTableConfig<T>(databaseType, clazz, tableName,
extractFieldTypes(databaseType, clazz, tableName));
} | java | public static <T> DatabaseTableConfig<T> fromClass(DatabaseType databaseType, Class<T> clazz) throws SQLException {
String tableName = extractTableName(databaseType, clazz);
if (databaseType.isEntityNamesMustBeUpCase()) {
tableName = databaseType.upCaseEntityName(tableName);
}
return new DatabaseTableConfig<T>(databaseType, clazz, tableName,
extractFieldTypes(databaseType, clazz, tableName));
} | [
"public",
"static",
"<",
"T",
">",
"DatabaseTableConfig",
"<",
"T",
">",
"fromClass",
"(",
"DatabaseType",
"databaseType",
",",
"Class",
"<",
"T",
">",
"clazz",
")",
"throws",
"SQLException",
"{",
"String",
"tableName",
"=",
"extractTableName",
"(",
"databaseT... | Extract the DatabaseTableConfig for a particular class by looking for class and field annotations. This is used
by internal classes to configure a class. | [
"Extract",
"the",
"DatabaseTableConfig",
"for",
"a",
"particular",
"class",
"by",
"looking",
"for",
"class",
"and",
"field",
"annotations",
".",
"This",
"is",
"used",
"by",
"internal",
"classes",
"to",
"configure",
"a",
"class",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/DatabaseTableConfig.java#L167-L174 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/DatabaseTableConfig.java | DatabaseTableConfig.extractTableName | public static <T> String extractTableName(DatabaseType databaseType, Class<T> clazz) {
DatabaseTable databaseTable = clazz.getAnnotation(DatabaseTable.class);
String name = null;
if (databaseTable != null && databaseTable.tableName() != null && databaseTable.tableName().length() > 0) {
name = databaseTable.tableName();
}
if (name == null && javaxPersistenceConfigurer != null) {
name = javaxPersistenceConfigurer.getEntityName(clazz);
}
if (name == null) {
// if the name isn't specified, it is the class name lowercased
if (databaseType == null) {
// database-type is optional so if it is not specified we just use english
name = clazz.getSimpleName().toLowerCase(Locale.ENGLISH);
} else {
name = databaseType.downCaseString(clazz.getSimpleName(), true);
}
}
return name;
} | java | public static <T> String extractTableName(DatabaseType databaseType, Class<T> clazz) {
DatabaseTable databaseTable = clazz.getAnnotation(DatabaseTable.class);
String name = null;
if (databaseTable != null && databaseTable.tableName() != null && databaseTable.tableName().length() > 0) {
name = databaseTable.tableName();
}
if (name == null && javaxPersistenceConfigurer != null) {
name = javaxPersistenceConfigurer.getEntityName(clazz);
}
if (name == null) {
// if the name isn't specified, it is the class name lowercased
if (databaseType == null) {
// database-type is optional so if it is not specified we just use english
name = clazz.getSimpleName().toLowerCase(Locale.ENGLISH);
} else {
name = databaseType.downCaseString(clazz.getSimpleName(), true);
}
}
return name;
} | [
"public",
"static",
"<",
"T",
">",
"String",
"extractTableName",
"(",
"DatabaseType",
"databaseType",
",",
"Class",
"<",
"T",
">",
"clazz",
")",
"{",
"DatabaseTable",
"databaseTable",
"=",
"clazz",
".",
"getAnnotation",
"(",
"DatabaseTable",
".",
"class",
")",... | Extract and return the table name for a class. | [
"Extract",
"and",
"return",
"the",
"table",
"name",
"for",
"a",
"class",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/DatabaseTableConfig.java#L179-L198 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/logger/LocalLog.java | LocalLog.openLogFile | public static void openLogFile(String logPath) {
if (logPath == null) {
printStream = System.out;
} else {
try {
printStream = new PrintStream(new File(logPath));
} catch (FileNotFoundException e) {
throw new IllegalArgumentException("Log file " + logPath + " was not found", e);
}
}
} | java | public static void openLogFile(String logPath) {
if (logPath == null) {
printStream = System.out;
} else {
try {
printStream = new PrintStream(new File(logPath));
} catch (FileNotFoundException e) {
throw new IllegalArgumentException("Log file " + logPath + " was not found", e);
}
}
} | [
"public",
"static",
"void",
"openLogFile",
"(",
"String",
"logPath",
")",
"{",
"if",
"(",
"logPath",
"==",
"null",
")",
"{",
"printStream",
"=",
"System",
".",
"out",
";",
"}",
"else",
"{",
"try",
"{",
"printStream",
"=",
"new",
"PrintStream",
"(",
"ne... | Reopen the associated static logging stream. Set to null to redirect to System.out. | [
"Reopen",
"the",
"associated",
"static",
"logging",
"stream",
".",
"Set",
"to",
"null",
"to",
"redirect",
"to",
"System",
".",
"out",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/logger/LocalLog.java#L120-L130 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/StatementExecutor.java | StatementExecutor.queryForCountStar | public long queryForCountStar(DatabaseConnection databaseConnection) throws SQLException {
if (countStarQuery == null) {
StringBuilder sb = new StringBuilder(64);
sb.append("SELECT COUNT(*) FROM ");
databaseType.appendEscapedEntityName(sb, tableInfo.getTableName());
countStarQuery = sb.toString();
}
long count = databaseConnection.queryForLong(countStarQuery);
logger.debug("query of '{}' returned {}", countStarQuery, count);
return count;
} | java | public long queryForCountStar(DatabaseConnection databaseConnection) throws SQLException {
if (countStarQuery == null) {
StringBuilder sb = new StringBuilder(64);
sb.append("SELECT COUNT(*) FROM ");
databaseType.appendEscapedEntityName(sb, tableInfo.getTableName());
countStarQuery = sb.toString();
}
long count = databaseConnection.queryForLong(countStarQuery);
logger.debug("query of '{}' returned {}", countStarQuery, count);
return count;
} | [
"public",
"long",
"queryForCountStar",
"(",
"DatabaseConnection",
"databaseConnection",
")",
"throws",
"SQLException",
"{",
"if",
"(",
"countStarQuery",
"==",
"null",
")",
"{",
"StringBuilder",
"sb",
"=",
"new",
"StringBuilder",
"(",
"64",
")",
";",
"sb",
".",
... | Return a long value which is the number of rows in the table. | [
"Return",
"a",
"long",
"value",
"which",
"is",
"the",
"number",
"of",
"rows",
"in",
"the",
"table",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/StatementExecutor.java#L132-L142 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/StatementExecutor.java | StatementExecutor.queryForLong | public long queryForLong(DatabaseConnection databaseConnection, PreparedStmt<T> preparedStmt) throws SQLException {
CompiledStatement compiledStatement = preparedStmt.compile(databaseConnection, StatementType.SELECT_LONG);
DatabaseResults results = null;
try {
results = compiledStatement.runQuery(null);
if (results.first()) {
return results.getLong(0);
} else {
throw new SQLException("No result found in queryForLong: " + preparedStmt.getStatement());
}
} finally {
IOUtils.closeThrowSqlException(results, "results");
IOUtils.closeThrowSqlException(compiledStatement, "compiled statement");
}
} | java | public long queryForLong(DatabaseConnection databaseConnection, PreparedStmt<T> preparedStmt) throws SQLException {
CompiledStatement compiledStatement = preparedStmt.compile(databaseConnection, StatementType.SELECT_LONG);
DatabaseResults results = null;
try {
results = compiledStatement.runQuery(null);
if (results.first()) {
return results.getLong(0);
} else {
throw new SQLException("No result found in queryForLong: " + preparedStmt.getStatement());
}
} finally {
IOUtils.closeThrowSqlException(results, "results");
IOUtils.closeThrowSqlException(compiledStatement, "compiled statement");
}
} | [
"public",
"long",
"queryForLong",
"(",
"DatabaseConnection",
"databaseConnection",
",",
"PreparedStmt",
"<",
"T",
">",
"preparedStmt",
")",
"throws",
"SQLException",
"{",
"CompiledStatement",
"compiledStatement",
"=",
"preparedStmt",
".",
"compile",
"(",
"databaseConnec... | Return a long value from a prepared query. | [
"Return",
"a",
"long",
"value",
"from",
"a",
"prepared",
"query",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/StatementExecutor.java#L147-L161 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/StatementExecutor.java | StatementExecutor.buildIterator | public SelectIterator<T, ID> buildIterator(BaseDaoImpl<T, ID> classDao, ConnectionSource connectionSource,
int resultFlags, ObjectCache objectCache) throws SQLException {
prepareQueryForAll();
return buildIterator(classDao, connectionSource, preparedQueryForAll, objectCache, resultFlags);
} | java | public SelectIterator<T, ID> buildIterator(BaseDaoImpl<T, ID> classDao, ConnectionSource connectionSource,
int resultFlags, ObjectCache objectCache) throws SQLException {
prepareQueryForAll();
return buildIterator(classDao, connectionSource, preparedQueryForAll, objectCache, resultFlags);
} | [
"public",
"SelectIterator",
"<",
"T",
",",
"ID",
">",
"buildIterator",
"(",
"BaseDaoImpl",
"<",
"T",
",",
"ID",
">",
"classDao",
",",
"ConnectionSource",
"connectionSource",
",",
"int",
"resultFlags",
",",
"ObjectCache",
"objectCache",
")",
"throws",
"SQLExcepti... | Create and return a SelectIterator for the class using the default mapped query for all statement. | [
"Create",
"and",
"return",
"a",
"SelectIterator",
"for",
"the",
"class",
"using",
"the",
"default",
"mapped",
"query",
"for",
"all",
"statement",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/StatementExecutor.java#L214-L218 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/StatementExecutor.java | StatementExecutor.updateRaw | public int updateRaw(DatabaseConnection connection, String statement, String[] arguments) throws SQLException {
logger.debug("running raw update statement: {}", statement);
if (arguments.length > 0) {
// need to do the (Object) cast to force args to be a single object
logger.trace("update arguments: {}", (Object) arguments);
}
CompiledStatement compiledStatement = connection.compileStatement(statement, StatementType.UPDATE, noFieldTypes,
DatabaseConnection.DEFAULT_RESULT_FLAGS, false);
try {
assignStatementArguments(compiledStatement, arguments);
return compiledStatement.runUpdate();
} finally {
IOUtils.closeThrowSqlException(compiledStatement, "compiled statement");
}
} | java | public int updateRaw(DatabaseConnection connection, String statement, String[] arguments) throws SQLException {
logger.debug("running raw update statement: {}", statement);
if (arguments.length > 0) {
// need to do the (Object) cast to force args to be a single object
logger.trace("update arguments: {}", (Object) arguments);
}
CompiledStatement compiledStatement = connection.compileStatement(statement, StatementType.UPDATE, noFieldTypes,
DatabaseConnection.DEFAULT_RESULT_FLAGS, false);
try {
assignStatementArguments(compiledStatement, arguments);
return compiledStatement.runUpdate();
} finally {
IOUtils.closeThrowSqlException(compiledStatement, "compiled statement");
}
} | [
"public",
"int",
"updateRaw",
"(",
"DatabaseConnection",
"connection",
",",
"String",
"statement",
",",
"String",
"[",
"]",
"arguments",
")",
"throws",
"SQLException",
"{",
"logger",
".",
"debug",
"(",
"\"running raw update statement: {}\"",
",",
"statement",
")",
... | Return the number of rows affected. | [
"Return",
"the",
"number",
"of",
"rows",
"affected",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/StatementExecutor.java#L408-L422 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/StatementExecutor.java | StatementExecutor.create | public int create(DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException {
if (mappedInsert == null) {
mappedInsert = MappedCreate.build(dao, tableInfo);
}
int result = mappedInsert.insert(databaseType, databaseConnection, data, objectCache);
if (dao != null && !localIsInBatchMode.get()) {
dao.notifyChanges();
}
return result;
} | java | public int create(DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException {
if (mappedInsert == null) {
mappedInsert = MappedCreate.build(dao, tableInfo);
}
int result = mappedInsert.insert(databaseType, databaseConnection, data, objectCache);
if (dao != null && !localIsInBatchMode.get()) {
dao.notifyChanges();
}
return result;
} | [
"public",
"int",
"create",
"(",
"DatabaseConnection",
"databaseConnection",
",",
"T",
"data",
",",
"ObjectCache",
"objectCache",
")",
"throws",
"SQLException",
"{",
"if",
"(",
"mappedInsert",
"==",
"null",
")",
"{",
"mappedInsert",
"=",
"MappedCreate",
".",
"bui... | Create a new entry in the database from an object. | [
"Create",
"a",
"new",
"entry",
"in",
"the",
"database",
"from",
"an",
"object",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/StatementExecutor.java#L454-L463 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/StatementExecutor.java | StatementExecutor.updateId | public int updateId(DatabaseConnection databaseConnection, T data, ID newId, ObjectCache objectCache)
throws SQLException {
if (mappedUpdateId == null) {
mappedUpdateId = MappedUpdateId.build(dao, tableInfo);
}
int result = mappedUpdateId.execute(databaseConnection, data, newId, objectCache);
if (dao != null && !localIsInBatchMode.get()) {
dao.notifyChanges();
}
return result;
} | java | public int updateId(DatabaseConnection databaseConnection, T data, ID newId, ObjectCache objectCache)
throws SQLException {
if (mappedUpdateId == null) {
mappedUpdateId = MappedUpdateId.build(dao, tableInfo);
}
int result = mappedUpdateId.execute(databaseConnection, data, newId, objectCache);
if (dao != null && !localIsInBatchMode.get()) {
dao.notifyChanges();
}
return result;
} | [
"public",
"int",
"updateId",
"(",
"DatabaseConnection",
"databaseConnection",
",",
"T",
"data",
",",
"ID",
"newId",
",",
"ObjectCache",
"objectCache",
")",
"throws",
"SQLException",
"{",
"if",
"(",
"mappedUpdateId",
"==",
"null",
")",
"{",
"mappedUpdateId",
"=",... | Update an object in the database to change its id to the newId parameter. | [
"Update",
"an",
"object",
"in",
"the",
"database",
"to",
"change",
"its",
"id",
"to",
"the",
"newId",
"parameter",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/StatementExecutor.java#L482-L492 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/StatementExecutor.java | StatementExecutor.update | public int update(DatabaseConnection databaseConnection, PreparedUpdate<T> preparedUpdate) throws SQLException {
CompiledStatement compiledStatement = preparedUpdate.compile(databaseConnection, StatementType.UPDATE);
try {
int result = compiledStatement.runUpdate();
if (dao != null && !localIsInBatchMode.get()) {
dao.notifyChanges();
}
return result;
} finally {
IOUtils.closeThrowSqlException(compiledStatement, "compiled statement");
}
} | java | public int update(DatabaseConnection databaseConnection, PreparedUpdate<T> preparedUpdate) throws SQLException {
CompiledStatement compiledStatement = preparedUpdate.compile(databaseConnection, StatementType.UPDATE);
try {
int result = compiledStatement.runUpdate();
if (dao != null && !localIsInBatchMode.get()) {
dao.notifyChanges();
}
return result;
} finally {
IOUtils.closeThrowSqlException(compiledStatement, "compiled statement");
}
} | [
"public",
"int",
"update",
"(",
"DatabaseConnection",
"databaseConnection",
",",
"PreparedUpdate",
"<",
"T",
">",
"preparedUpdate",
")",
"throws",
"SQLException",
"{",
"CompiledStatement",
"compiledStatement",
"=",
"preparedUpdate",
".",
"compile",
"(",
"databaseConnect... | Update rows in the database. | [
"Update",
"rows",
"in",
"the",
"database",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/StatementExecutor.java#L497-L508 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/StatementExecutor.java | StatementExecutor.refresh | public int refresh(DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException {
if (mappedRefresh == null) {
mappedRefresh = MappedRefresh.build(dao, tableInfo);
}
return mappedRefresh.executeRefresh(databaseConnection, data, objectCache);
} | java | public int refresh(DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException {
if (mappedRefresh == null) {
mappedRefresh = MappedRefresh.build(dao, tableInfo);
}
return mappedRefresh.executeRefresh(databaseConnection, data, objectCache);
} | [
"public",
"int",
"refresh",
"(",
"DatabaseConnection",
"databaseConnection",
",",
"T",
"data",
",",
"ObjectCache",
"objectCache",
")",
"throws",
"SQLException",
"{",
"if",
"(",
"mappedRefresh",
"==",
"null",
")",
"{",
"mappedRefresh",
"=",
"MappedRefresh",
".",
... | Does a query for the object's Id and copies in each of the field values from the database to refresh the data
parameter. | [
"Does",
"a",
"query",
"for",
"the",
"object",
"s",
"Id",
"and",
"copies",
"in",
"each",
"of",
"the",
"field",
"values",
"from",
"the",
"database",
"to",
"refresh",
"the",
"data",
"parameter",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/StatementExecutor.java#L514-L519 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/StatementExecutor.java | StatementExecutor.delete | public int delete(DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException {
if (mappedDelete == null) {
mappedDelete = MappedDelete.build(dao, tableInfo);
}
int result = mappedDelete.delete(databaseConnection, data, objectCache);
if (dao != null && !localIsInBatchMode.get()) {
dao.notifyChanges();
}
return result;
} | java | public int delete(DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException {
if (mappedDelete == null) {
mappedDelete = MappedDelete.build(dao, tableInfo);
}
int result = mappedDelete.delete(databaseConnection, data, objectCache);
if (dao != null && !localIsInBatchMode.get()) {
dao.notifyChanges();
}
return result;
} | [
"public",
"int",
"delete",
"(",
"DatabaseConnection",
"databaseConnection",
",",
"T",
"data",
",",
"ObjectCache",
"objectCache",
")",
"throws",
"SQLException",
"{",
"if",
"(",
"mappedDelete",
"==",
"null",
")",
"{",
"mappedDelete",
"=",
"MappedDelete",
".",
"bui... | Delete an object from the database. | [
"Delete",
"an",
"object",
"from",
"the",
"database",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/StatementExecutor.java#L524-L533 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/StatementExecutor.java | StatementExecutor.deleteById | public int deleteById(DatabaseConnection databaseConnection, ID id, ObjectCache objectCache) throws SQLException {
if (mappedDelete == null) {
mappedDelete = MappedDelete.build(dao, tableInfo);
}
int result = mappedDelete.deleteById(databaseConnection, id, objectCache);
if (dao != null && !localIsInBatchMode.get()) {
dao.notifyChanges();
}
return result;
} | java | public int deleteById(DatabaseConnection databaseConnection, ID id, ObjectCache objectCache) throws SQLException {
if (mappedDelete == null) {
mappedDelete = MappedDelete.build(dao, tableInfo);
}
int result = mappedDelete.deleteById(databaseConnection, id, objectCache);
if (dao != null && !localIsInBatchMode.get()) {
dao.notifyChanges();
}
return result;
} | [
"public",
"int",
"deleteById",
"(",
"DatabaseConnection",
"databaseConnection",
",",
"ID",
"id",
",",
"ObjectCache",
"objectCache",
")",
"throws",
"SQLException",
"{",
"if",
"(",
"mappedDelete",
"==",
"null",
")",
"{",
"mappedDelete",
"=",
"MappedDelete",
".",
"... | Delete an object from the database by id. | [
"Delete",
"an",
"object",
"from",
"the",
"database",
"by",
"id",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/StatementExecutor.java#L538-L547 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/StatementExecutor.java | StatementExecutor.delete | public int delete(DatabaseConnection databaseConnection, PreparedDelete<T> preparedDelete) throws SQLException {
CompiledStatement compiledStatement = preparedDelete.compile(databaseConnection, StatementType.DELETE);
try {
int result = compiledStatement.runUpdate();
if (dao != null && !localIsInBatchMode.get()) {
dao.notifyChanges();
}
return result;
} finally {
IOUtils.closeThrowSqlException(compiledStatement, "compiled statement");
}
} | java | public int delete(DatabaseConnection databaseConnection, PreparedDelete<T> preparedDelete) throws SQLException {
CompiledStatement compiledStatement = preparedDelete.compile(databaseConnection, StatementType.DELETE);
try {
int result = compiledStatement.runUpdate();
if (dao != null && !localIsInBatchMode.get()) {
dao.notifyChanges();
}
return result;
} finally {
IOUtils.closeThrowSqlException(compiledStatement, "compiled statement");
}
} | [
"public",
"int",
"delete",
"(",
"DatabaseConnection",
"databaseConnection",
",",
"PreparedDelete",
"<",
"T",
">",
"preparedDelete",
")",
"throws",
"SQLException",
"{",
"CompiledStatement",
"compiledStatement",
"=",
"preparedDelete",
".",
"compile",
"(",
"databaseConnect... | Delete rows that match the prepared statement. | [
"Delete",
"rows",
"that",
"match",
"the",
"prepared",
"statement",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/StatementExecutor.java#L578-L589 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/StatementExecutor.java | StatementExecutor.callBatchTasks | public <CT> CT callBatchTasks(ConnectionSource connectionSource, Callable<CT> callable) throws SQLException {
if (connectionSource.isSingleConnection(tableInfo.getTableName())) {
synchronized (this) {
return doCallBatchTasks(connectionSource, callable);
}
} else {
return doCallBatchTasks(connectionSource, callable);
}
} | java | public <CT> CT callBatchTasks(ConnectionSource connectionSource, Callable<CT> callable) throws SQLException {
if (connectionSource.isSingleConnection(tableInfo.getTableName())) {
synchronized (this) {
return doCallBatchTasks(connectionSource, callable);
}
} else {
return doCallBatchTasks(connectionSource, callable);
}
} | [
"public",
"<",
"CT",
">",
"CT",
"callBatchTasks",
"(",
"ConnectionSource",
"connectionSource",
",",
"Callable",
"<",
"CT",
">",
"callable",
")",
"throws",
"SQLException",
"{",
"if",
"(",
"connectionSource",
".",
"isSingleConnection",
"(",
"tableInfo",
".",
"getT... | Call batch tasks inside of a connection which may, or may not, have been "saved". | [
"Call",
"batch",
"tasks",
"inside",
"of",
"a",
"connection",
"which",
"may",
"or",
"may",
"not",
"have",
"been",
"saved",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/StatementExecutor.java#L594-L602 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/misc/SqlExceptionUtil.java | SqlExceptionUtil.create | public static SQLException create(String message, Throwable cause) {
SQLException sqlException;
if (cause instanceof SQLException) {
// if the cause is another SQLException, pass alot of the SQL state
sqlException = new SQLException(message, ((SQLException) cause).getSQLState());
} else {
sqlException = new SQLException(message);
}
sqlException.initCause(cause);
return sqlException;
} | java | public static SQLException create(String message, Throwable cause) {
SQLException sqlException;
if (cause instanceof SQLException) {
// if the cause is another SQLException, pass alot of the SQL state
sqlException = new SQLException(message, ((SQLException) cause).getSQLState());
} else {
sqlException = new SQLException(message);
}
sqlException.initCause(cause);
return sqlException;
} | [
"public",
"static",
"SQLException",
"create",
"(",
"String",
"message",
",",
"Throwable",
"cause",
")",
"{",
"SQLException",
"sqlException",
";",
"if",
"(",
"cause",
"instanceof",
"SQLException",
")",
"{",
"// if the cause is another SQLException, pass alot of the SQL sta... | Convenience method to allow a cause. Grrrr. | [
"Convenience",
"method",
"to",
"allow",
"a",
"cause",
".",
"Grrrr",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/misc/SqlExceptionUtil.java#L21-L31 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/dao/BaseDaoImpl.java | BaseDaoImpl.initialize | public void initialize() throws SQLException {
if (initialized) {
// just skip it if already initialized
return;
}
if (connectionSource == null) {
throw new IllegalStateException("connectionSource was never set on " + getClass().getSimpleName());
}
databaseType = connectionSource.getDatabaseType();
if (databaseType == null) {
throw new IllegalStateException(
"connectionSource is getting a null DatabaseType in " + getClass().getSimpleName());
}
if (tableConfig == null) {
tableInfo = new TableInfo<T, ID>(databaseType, dataClass);
} else {
tableConfig.extractFieldTypes(databaseType);
tableInfo = new TableInfo<T, ID>(databaseType, tableConfig);
}
statementExecutor = new StatementExecutor<T, ID>(databaseType, tableInfo, this);
/*
* This is a bit complex. Initially, when we were configuring the field types, external DAO information would be
* configured for auto-refresh, foreign BaseDaoEnabled classes, and foreign-collections. This would cause the
* system to go recursive and for class loops, a stack overflow.
*
* Then we fixed this by putting a level counter in the FieldType constructor that would stop the configurations
* when we reach some recursion level. But this created some bad problems because we were using the DaoManager
* to cache the created DAOs that had been constructed already limited by the level.
*
* What we do now is have a 2 phase initialization. The constructor initializes most of the fields but then we
* go back and call FieldType.configDaoInformation() after we are done. So for every DAO that is initialized
* here, we have to see if it is the top DAO. If not we save it for dao configuration later.
*/
List<BaseDaoImpl<?, ?>> daoConfigList = daoConfigLevelLocal.get();
daoConfigList.add(this);
if (daoConfigList.size() > 1) {
// if we have recursed then just save the dao for later configuration
return;
}
try {
/*
* WARNING: We do _not_ use an iterator here because we may be adding to the list as we process it and we'll
* get exceptions otherwise. This is an ArrayList so the get(i) should be efficient.
*
* Also, do _not_ get a copy of daoConfigLevel.doArray because that array may be replaced by another, larger
* one during the recursion.
*/
for (int i = 0; i < daoConfigList.size(); i++) {
BaseDaoImpl<?, ?> dao = daoConfigList.get(i);
/*
* Here's another complex bit. The first DAO that is being constructed as part of a DAO chain is not yet
* in the DaoManager cache. If we continue onward we might come back around and try to configure this
* DAO again. Forcing it into the cache here makes sure it won't be configured twice. This will cause it
* to be stuck in twice when it returns out to the DaoManager but that's a small price to pay. This also
* applies to self-referencing classes.
*/
DaoManager.registerDao(connectionSource, dao);
try {
// config our fields which may go recursive
for (FieldType fieldType : dao.getTableInfo().getFieldTypes()) {
fieldType.configDaoInformation(connectionSource, dao.getDataClass());
}
} catch (SQLException e) {
// unregister the DAO we just pre-registered
DaoManager.unregisterDao(connectionSource, dao);
throw e;
}
// it's now been fully initialized
dao.initialized = true;
}
} finally {
// if we throw we want to clear our class hierarchy here
daoConfigList.clear();
daoConfigLevelLocal.remove();
}
} | java | public void initialize() throws SQLException {
if (initialized) {
// just skip it if already initialized
return;
}
if (connectionSource == null) {
throw new IllegalStateException("connectionSource was never set on " + getClass().getSimpleName());
}
databaseType = connectionSource.getDatabaseType();
if (databaseType == null) {
throw new IllegalStateException(
"connectionSource is getting a null DatabaseType in " + getClass().getSimpleName());
}
if (tableConfig == null) {
tableInfo = new TableInfo<T, ID>(databaseType, dataClass);
} else {
tableConfig.extractFieldTypes(databaseType);
tableInfo = new TableInfo<T, ID>(databaseType, tableConfig);
}
statementExecutor = new StatementExecutor<T, ID>(databaseType, tableInfo, this);
/*
* This is a bit complex. Initially, when we were configuring the field types, external DAO information would be
* configured for auto-refresh, foreign BaseDaoEnabled classes, and foreign-collections. This would cause the
* system to go recursive and for class loops, a stack overflow.
*
* Then we fixed this by putting a level counter in the FieldType constructor that would stop the configurations
* when we reach some recursion level. But this created some bad problems because we were using the DaoManager
* to cache the created DAOs that had been constructed already limited by the level.
*
* What we do now is have a 2 phase initialization. The constructor initializes most of the fields but then we
* go back and call FieldType.configDaoInformation() after we are done. So for every DAO that is initialized
* here, we have to see if it is the top DAO. If not we save it for dao configuration later.
*/
List<BaseDaoImpl<?, ?>> daoConfigList = daoConfigLevelLocal.get();
daoConfigList.add(this);
if (daoConfigList.size() > 1) {
// if we have recursed then just save the dao for later configuration
return;
}
try {
/*
* WARNING: We do _not_ use an iterator here because we may be adding to the list as we process it and we'll
* get exceptions otherwise. This is an ArrayList so the get(i) should be efficient.
*
* Also, do _not_ get a copy of daoConfigLevel.doArray because that array may be replaced by another, larger
* one during the recursion.
*/
for (int i = 0; i < daoConfigList.size(); i++) {
BaseDaoImpl<?, ?> dao = daoConfigList.get(i);
/*
* Here's another complex bit. The first DAO that is being constructed as part of a DAO chain is not yet
* in the DaoManager cache. If we continue onward we might come back around and try to configure this
* DAO again. Forcing it into the cache here makes sure it won't be configured twice. This will cause it
* to be stuck in twice when it returns out to the DaoManager but that's a small price to pay. This also
* applies to self-referencing classes.
*/
DaoManager.registerDao(connectionSource, dao);
try {
// config our fields which may go recursive
for (FieldType fieldType : dao.getTableInfo().getFieldTypes()) {
fieldType.configDaoInformation(connectionSource, dao.getDataClass());
}
} catch (SQLException e) {
// unregister the DAO we just pre-registered
DaoManager.unregisterDao(connectionSource, dao);
throw e;
}
// it's now been fully initialized
dao.initialized = true;
}
} finally {
// if we throw we want to clear our class hierarchy here
daoConfigList.clear();
daoConfigLevelLocal.remove();
}
} | [
"public",
"void",
"initialize",
"(",
")",
"throws",
"SQLException",
"{",
"if",
"(",
"initialized",
")",
"{",
"// just skip it if already initialized",
"return",
";",
"}",
"if",
"(",
"connectionSource",
"==",
"null",
")",
"{",
"throw",
"new",
"IllegalStateException... | Initialize the various DAO configurations after the various setters have been called. | [
"Initialize",
"the",
"various",
"DAO",
"configurations",
"after",
"the",
"various",
"setters",
"have",
"been",
"called",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/dao/BaseDaoImpl.java#L143-L225 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/dao/BaseDaoImpl.java | BaseDaoImpl.createDao | static <T, ID> Dao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz) throws SQLException {
return new BaseDaoImpl<T, ID>(connectionSource, clazz) {
};
} | java | static <T, ID> Dao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz) throws SQLException {
return new BaseDaoImpl<T, ID>(connectionSource, clazz) {
};
} | [
"static",
"<",
"T",
",",
"ID",
">",
"Dao",
"<",
"T",
",",
"ID",
">",
"createDao",
"(",
"ConnectionSource",
"connectionSource",
",",
"Class",
"<",
"T",
">",
"clazz",
")",
"throws",
"SQLException",
"{",
"return",
"new",
"BaseDaoImpl",
"<",
"T",
",",
"ID"... | Helper method to create a Dao object without having to define a class. Dao classes are supposed to be convenient
but if you have a lot of classes, they can seem to be a pain.
<p>
<b>NOTE:</b> You should use {@link DaoManager#createDao(ConnectionSource, DatabaseTableConfig)} instead of this
method so you won't have to create the DAO multiple times.
</p> | [
"Helper",
"method",
"to",
"create",
"a",
"Dao",
"object",
"without",
"having",
"to",
"define",
"a",
"class",
".",
"Dao",
"classes",
"are",
"supposed",
"to",
"be",
"convenient",
"but",
"if",
"you",
"have",
"a",
"lot",
"of",
"classes",
"they",
"can",
"seem... | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/dao/BaseDaoImpl.java#L1059-L1062 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/dao/BaseDaoImpl.java | BaseDaoImpl.findNoArgConstructor | private Constructor<T> findNoArgConstructor(Class<T> dataClass) {
Constructor<T>[] constructors;
try {
@SuppressWarnings("unchecked")
Constructor<T>[] consts = (Constructor<T>[]) dataClass.getDeclaredConstructors();
// i do this [grossness] to be able to move the Suppress inside the method
constructors = consts;
} catch (Exception e) {
throw new IllegalArgumentException("Can't lookup declared constructors for " + dataClass, e);
}
for (Constructor<T> con : constructors) {
if (con.getParameterTypes().length == 0) {
if (!con.isAccessible()) {
try {
con.setAccessible(true);
} catch (SecurityException e) {
throw new IllegalArgumentException("Could not open access to constructor for " + dataClass);
}
}
return con;
}
}
if (dataClass.getEnclosingClass() == null) {
throw new IllegalArgumentException("Can't find a no-arg constructor for " + dataClass);
} else {
throw new IllegalArgumentException(
"Can't find a no-arg constructor for " + dataClass + ". Missing static on inner class?");
}
} | java | private Constructor<T> findNoArgConstructor(Class<T> dataClass) {
Constructor<T>[] constructors;
try {
@SuppressWarnings("unchecked")
Constructor<T>[] consts = (Constructor<T>[]) dataClass.getDeclaredConstructors();
// i do this [grossness] to be able to move the Suppress inside the method
constructors = consts;
} catch (Exception e) {
throw new IllegalArgumentException("Can't lookup declared constructors for " + dataClass, e);
}
for (Constructor<T> con : constructors) {
if (con.getParameterTypes().length == 0) {
if (!con.isAccessible()) {
try {
con.setAccessible(true);
} catch (SecurityException e) {
throw new IllegalArgumentException("Could not open access to constructor for " + dataClass);
}
}
return con;
}
}
if (dataClass.getEnclosingClass() == null) {
throw new IllegalArgumentException("Can't find a no-arg constructor for " + dataClass);
} else {
throw new IllegalArgumentException(
"Can't find a no-arg constructor for " + dataClass + ". Missing static on inner class?");
}
} | [
"private",
"Constructor",
"<",
"T",
">",
"findNoArgConstructor",
"(",
"Class",
"<",
"T",
">",
"dataClass",
")",
"{",
"Constructor",
"<",
"T",
">",
"[",
"]",
"constructors",
";",
"try",
"{",
"@",
"SuppressWarnings",
"(",
"\"unchecked\"",
")",
"Constructor",
... | Locate the no arg constructor for the class. | [
"Locate",
"the",
"no",
"arg",
"constructor",
"for",
"the",
"class",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/dao/BaseDaoImpl.java#L1176-L1204 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/DatabaseFieldConfig.java | DatabaseFieldConfig.findGetMethod | public static Method findGetMethod(Field field, DatabaseType databaseType, boolean throwExceptions)
throws IllegalArgumentException {
Method fieldGetMethod = findMethodFromNames(field, true, throwExceptions,
methodFromField(field, "get", databaseType, true), methodFromField(field, "get", databaseType, false),
methodFromField(field, "is", databaseType, true), methodFromField(field, "is", databaseType, false));
if (fieldGetMethod == null) {
return null;
}
if (fieldGetMethod.getReturnType() != field.getType()) {
if (throwExceptions) {
throw new IllegalArgumentException("Return type of get method " + fieldGetMethod.getName()
+ " does not return " + field.getType());
} else {
return null;
}
}
return fieldGetMethod;
} | java | public static Method findGetMethod(Field field, DatabaseType databaseType, boolean throwExceptions)
throws IllegalArgumentException {
Method fieldGetMethod = findMethodFromNames(field, true, throwExceptions,
methodFromField(field, "get", databaseType, true), methodFromField(field, "get", databaseType, false),
methodFromField(field, "is", databaseType, true), methodFromField(field, "is", databaseType, false));
if (fieldGetMethod == null) {
return null;
}
if (fieldGetMethod.getReturnType() != field.getType()) {
if (throwExceptions) {
throw new IllegalArgumentException("Return type of get method " + fieldGetMethod.getName()
+ " does not return " + field.getType());
} else {
return null;
}
}
return fieldGetMethod;
} | [
"public",
"static",
"Method",
"findGetMethod",
"(",
"Field",
"field",
",",
"DatabaseType",
"databaseType",
",",
"boolean",
"throwExceptions",
")",
"throws",
"IllegalArgumentException",
"{",
"Method",
"fieldGetMethod",
"=",
"findMethodFromNames",
"(",
"field",
",",
"tr... | Find and return the appropriate getter method for field.
@return Get method or null (or throws IllegalArgumentException) if none found. | [
"Find",
"and",
"return",
"the",
"appropriate",
"getter",
"method",
"for",
"field",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/DatabaseFieldConfig.java#L546-L563 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/DatabaseFieldConfig.java | DatabaseFieldConfig.findSetMethod | public static Method findSetMethod(Field field, DatabaseType databaseType, boolean throwExceptions)
throws IllegalArgumentException {
Method fieldSetMethod = findMethodFromNames(field, false, throwExceptions,
methodFromField(field, "set", databaseType, true), methodFromField(field, "set", databaseType, false));
if (fieldSetMethod == null) {
return null;
}
if (fieldSetMethod.getReturnType() != void.class) {
if (throwExceptions) {
throw new IllegalArgumentException("Return type of set method " + fieldSetMethod.getName() + " returns "
+ fieldSetMethod.getReturnType() + " instead of void");
} else {
return null;
}
}
return fieldSetMethod;
} | java | public static Method findSetMethod(Field field, DatabaseType databaseType, boolean throwExceptions)
throws IllegalArgumentException {
Method fieldSetMethod = findMethodFromNames(field, false, throwExceptions,
methodFromField(field, "set", databaseType, true), methodFromField(field, "set", databaseType, false));
if (fieldSetMethod == null) {
return null;
}
if (fieldSetMethod.getReturnType() != void.class) {
if (throwExceptions) {
throw new IllegalArgumentException("Return type of set method " + fieldSetMethod.getName() + " returns "
+ fieldSetMethod.getReturnType() + " instead of void");
} else {
return null;
}
}
return fieldSetMethod;
} | [
"public",
"static",
"Method",
"findSetMethod",
"(",
"Field",
"field",
",",
"DatabaseType",
"databaseType",
",",
"boolean",
"throwExceptions",
")",
"throws",
"IllegalArgumentException",
"{",
"Method",
"fieldSetMethod",
"=",
"findMethodFromNames",
"(",
"field",
",",
"fa... | Find and return the appropriate setter method for field.
@return Set method or null (or throws IllegalArgumentException) if none found. | [
"Find",
"and",
"return",
"the",
"appropriate",
"setter",
"method",
"for",
"field",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/DatabaseFieldConfig.java#L570-L586 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/DatabaseFieldConfig.java | DatabaseFieldConfig.postProcess | public void postProcess() {
if (foreignColumnName != null) {
foreignAutoRefresh = true;
}
if (foreignAutoRefresh && maxForeignAutoRefreshLevel == NO_MAX_FOREIGN_AUTO_REFRESH_LEVEL_SPECIFIED) {
maxForeignAutoRefreshLevel = DatabaseField.DEFAULT_MAX_FOREIGN_AUTO_REFRESH_LEVEL;
}
} | java | public void postProcess() {
if (foreignColumnName != null) {
foreignAutoRefresh = true;
}
if (foreignAutoRefresh && maxForeignAutoRefreshLevel == NO_MAX_FOREIGN_AUTO_REFRESH_LEVEL_SPECIFIED) {
maxForeignAutoRefreshLevel = DatabaseField.DEFAULT_MAX_FOREIGN_AUTO_REFRESH_LEVEL;
}
} | [
"public",
"void",
"postProcess",
"(",
")",
"{",
"if",
"(",
"foreignColumnName",
"!=",
"null",
")",
"{",
"foreignAutoRefresh",
"=",
"true",
";",
"}",
"if",
"(",
"foreignAutoRefresh",
"&&",
"maxForeignAutoRefreshLevel",
"==",
"NO_MAX_FOREIGN_AUTO_REFRESH_LEVEL_SPECIFIED... | Process the settings when we are going to consume them. | [
"Process",
"the",
"settings",
"when",
"we",
"are",
"going",
"to",
"consume",
"them",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/DatabaseFieldConfig.java#L642-L649 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/DatabaseFieldConfig.java | DatabaseFieldConfig.findMatchingEnumVal | public static Enum<?> findMatchingEnumVal(Field field, String unknownEnumName) {
if (unknownEnumName == null || unknownEnumName.length() == 0) {
return null;
}
for (Enum<?> enumVal : (Enum<?>[]) field.getType().getEnumConstants()) {
if (enumVal.name().equals(unknownEnumName)) {
return enumVal;
}
}
throw new IllegalArgumentException("Unknwown enum unknown name " + unknownEnumName + " for field " + field);
} | java | public static Enum<?> findMatchingEnumVal(Field field, String unknownEnumName) {
if (unknownEnumName == null || unknownEnumName.length() == 0) {
return null;
}
for (Enum<?> enumVal : (Enum<?>[]) field.getType().getEnumConstants()) {
if (enumVal.name().equals(unknownEnumName)) {
return enumVal;
}
}
throw new IllegalArgumentException("Unknwown enum unknown name " + unknownEnumName + " for field " + field);
} | [
"public",
"static",
"Enum",
"<",
"?",
">",
"findMatchingEnumVal",
"(",
"Field",
"field",
",",
"String",
"unknownEnumName",
")",
"{",
"if",
"(",
"unknownEnumName",
"==",
"null",
"||",
"unknownEnumName",
".",
"length",
"(",
")",
"==",
"0",
")",
"{",
"return"... | Internal method that finds the matching enum for a configured field that has the name argument.
@return The matching enum value or null if blank enum name.
@throws IllegalArgumentException
If the enum name is not known. | [
"Internal",
"method",
"that",
"finds",
"the",
"matching",
"enum",
"for",
"a",
"configured",
"field",
"that",
"has",
"the",
"name",
"argument",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/DatabaseFieldConfig.java#L658-L668 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/mapped/MappedRefresh.java | MappedRefresh.executeRefresh | public int executeRefresh(DatabaseConnection databaseConnection, T data, ObjectCache objectCache)
throws SQLException {
@SuppressWarnings("unchecked")
ID id = (ID) idField.extractJavaFieldValue(data);
// we don't care about the cache here
T result = super.execute(databaseConnection, id, null);
if (result == null) {
return 0;
}
// copy each field from the result into the passed in object
for (FieldType fieldType : resultsFieldTypes) {
if (fieldType != idField) {
fieldType.assignField(connectionSource, data, fieldType.extractJavaFieldValue(result), false,
objectCache);
}
}
return 1;
} | java | public int executeRefresh(DatabaseConnection databaseConnection, T data, ObjectCache objectCache)
throws SQLException {
@SuppressWarnings("unchecked")
ID id = (ID) idField.extractJavaFieldValue(data);
// we don't care about the cache here
T result = super.execute(databaseConnection, id, null);
if (result == null) {
return 0;
}
// copy each field from the result into the passed in object
for (FieldType fieldType : resultsFieldTypes) {
if (fieldType != idField) {
fieldType.assignField(connectionSource, data, fieldType.extractJavaFieldValue(result), false,
objectCache);
}
}
return 1;
} | [
"public",
"int",
"executeRefresh",
"(",
"DatabaseConnection",
"databaseConnection",
",",
"T",
"data",
",",
"ObjectCache",
"objectCache",
")",
"throws",
"SQLException",
"{",
"@",
"SuppressWarnings",
"(",
"\"unchecked\"",
")",
"ID",
"id",
"=",
"(",
"ID",
")",
"idF... | Execute our refresh query statement and then update all of the fields in data with the fields from the result.
@return 1 if we found the object in the table by id or 0 if not. | [
"Execute",
"our",
"refresh",
"query",
"statement",
"and",
"then",
"update",
"all",
"of",
"the",
"fields",
"in",
"data",
"with",
"the",
"fields",
"from",
"the",
"result",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/mapped/MappedRefresh.java#L29-L46 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/QueryBuilder.java | QueryBuilder.selectColumns | public QueryBuilder<T, ID> selectColumns(String... columns) {
for (String column : columns) {
addSelectColumnToList(column);
}
return this;
} | java | public QueryBuilder<T, ID> selectColumns(String... columns) {
for (String column : columns) {
addSelectColumnToList(column);
}
return this;
} | [
"public",
"QueryBuilder",
"<",
"T",
",",
"ID",
">",
"selectColumns",
"(",
"String",
"...",
"columns",
")",
"{",
"for",
"(",
"String",
"column",
":",
"columns",
")",
"{",
"addSelectColumnToList",
"(",
"column",
")",
";",
"}",
"return",
"this",
";",
"}"
] | Add columns to be returned by the SELECT query. If no columns are selected then all columns are returned by
default. For classes with id columns, the id column is added to the select list automagically. This can be called
multiple times to add more columns to select.
<p>
<b>WARNING:</b> If you specify any columns to return, then any foreign-collection fields will be returned as null
<i>unless</i> their {@link ForeignCollectionField#columnName()} is also in the list.
</p> | [
"Add",
"columns",
"to",
"be",
"returned",
"by",
"the",
"SELECT",
"query",
".",
"If",
"no",
"columns",
"are",
"selected",
"then",
"all",
"columns",
"are",
"returned",
"by",
"default",
".",
"For",
"classes",
"with",
"id",
"columns",
"the",
"id",
"column",
... | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/QueryBuilder.java#L115-L120 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/QueryBuilder.java | QueryBuilder.groupBy | public QueryBuilder<T, ID> groupBy(String columnName) {
FieldType fieldType = verifyColumnName(columnName);
if (fieldType.isForeignCollection()) {
throw new IllegalArgumentException("Can't groupBy foreign collection field: " + columnName);
}
addGroupBy(ColumnNameOrRawSql.withColumnName(columnName));
return this;
} | java | public QueryBuilder<T, ID> groupBy(String columnName) {
FieldType fieldType = verifyColumnName(columnName);
if (fieldType.isForeignCollection()) {
throw new IllegalArgumentException("Can't groupBy foreign collection field: " + columnName);
}
addGroupBy(ColumnNameOrRawSql.withColumnName(columnName));
return this;
} | [
"public",
"QueryBuilder",
"<",
"T",
",",
"ID",
">",
"groupBy",
"(",
"String",
"columnName",
")",
"{",
"FieldType",
"fieldType",
"=",
"verifyColumnName",
"(",
"columnName",
")",
";",
"if",
"(",
"fieldType",
".",
"isForeignCollection",
"(",
")",
")",
"{",
"t... | Add "GROUP BY" clause to the SQL query statement. This can be called multiple times to add additional "GROUP BY"
clauses.
<p>
NOTE: Use of this means that the resulting objects may not have a valid ID column value so cannot be deleted or
updated.
</p> | [
"Add",
"GROUP",
"BY",
"clause",
"to",
"the",
"SQL",
"query",
"statement",
".",
"This",
"can",
"be",
"called",
"multiple",
"times",
"to",
"add",
"additional",
"GROUP",
"BY",
"clauses",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/QueryBuilder.java#L154-L161 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/QueryBuilder.java | QueryBuilder.groupByRaw | public QueryBuilder<T, ID> groupByRaw(String rawSql) {
addGroupBy(ColumnNameOrRawSql.withRawSql(rawSql));
return this;
} | java | public QueryBuilder<T, ID> groupByRaw(String rawSql) {
addGroupBy(ColumnNameOrRawSql.withRawSql(rawSql));
return this;
} | [
"public",
"QueryBuilder",
"<",
"T",
",",
"ID",
">",
"groupByRaw",
"(",
"String",
"rawSql",
")",
"{",
"addGroupBy",
"(",
"ColumnNameOrRawSql",
".",
"withRawSql",
"(",
"rawSql",
")",
")",
";",
"return",
"this",
";",
"}"
] | Add a raw SQL "GROUP BY" clause to the SQL query statement. This should not include the "GROUP BY". | [
"Add",
"a",
"raw",
"SQL",
"GROUP",
"BY",
"clause",
"to",
"the",
"SQL",
"query",
"statement",
".",
"This",
"should",
"not",
"include",
"the",
"GROUP",
"BY",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/QueryBuilder.java#L166-L169 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/QueryBuilder.java | QueryBuilder.orderBy | public QueryBuilder<T, ID> orderBy(String columnName, boolean ascending) {
FieldType fieldType = verifyColumnName(columnName);
if (fieldType.isForeignCollection()) {
throw new IllegalArgumentException("Can't orderBy foreign collection field: " + columnName);
}
addOrderBy(new OrderBy(columnName, ascending));
return this;
} | java | public QueryBuilder<T, ID> orderBy(String columnName, boolean ascending) {
FieldType fieldType = verifyColumnName(columnName);
if (fieldType.isForeignCollection()) {
throw new IllegalArgumentException("Can't orderBy foreign collection field: " + columnName);
}
addOrderBy(new OrderBy(columnName, ascending));
return this;
} | [
"public",
"QueryBuilder",
"<",
"T",
",",
"ID",
">",
"orderBy",
"(",
"String",
"columnName",
",",
"boolean",
"ascending",
")",
"{",
"FieldType",
"fieldType",
"=",
"verifyColumnName",
"(",
"columnName",
")",
";",
"if",
"(",
"fieldType",
".",
"isForeignCollection... | Add "ORDER BY" clause to the SQL query statement. This can be called multiple times to add additional "ORDER BY"
clauses. Ones earlier are applied first. | [
"Add",
"ORDER",
"BY",
"clause",
"to",
"the",
"SQL",
"query",
"statement",
".",
"This",
"can",
"be",
"called",
"multiple",
"times",
"to",
"add",
"additional",
"ORDER",
"BY",
"clauses",
".",
"Ones",
"earlier",
"are",
"applied",
"first",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/QueryBuilder.java#L175-L182 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/QueryBuilder.java | QueryBuilder.orderByRaw | public QueryBuilder<T, ID> orderByRaw(String rawSql) {
addOrderBy(new OrderBy(rawSql, (ArgumentHolder[]) null));
return this;
} | java | public QueryBuilder<T, ID> orderByRaw(String rawSql) {
addOrderBy(new OrderBy(rawSql, (ArgumentHolder[]) null));
return this;
} | [
"public",
"QueryBuilder",
"<",
"T",
",",
"ID",
">",
"orderByRaw",
"(",
"String",
"rawSql",
")",
"{",
"addOrderBy",
"(",
"new",
"OrderBy",
"(",
"rawSql",
",",
"(",
"ArgumentHolder",
"[",
"]",
")",
"null",
")",
")",
";",
"return",
"this",
";",
"}"
] | Add raw SQL "ORDER BY" clause to the SQL query statement.
@param rawSql
The raw SQL order by clause. This should not include the "ORDER BY". | [
"Add",
"raw",
"SQL",
"ORDER",
"BY",
"clause",
"to",
"the",
"SQL",
"query",
"statement",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/QueryBuilder.java#L190-L193 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/QueryBuilder.java | QueryBuilder.join | public QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder) throws SQLException {
addJoinInfo(JoinType.INNER, null, null, joinedQueryBuilder, JoinWhereOperation.AND);
return this;
} | java | public QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder) throws SQLException {
addJoinInfo(JoinType.INNER, null, null, joinedQueryBuilder, JoinWhereOperation.AND);
return this;
} | [
"public",
"QueryBuilder",
"<",
"T",
",",
"ID",
">",
"join",
"(",
"QueryBuilder",
"<",
"?",
",",
"?",
">",
"joinedQueryBuilder",
")",
"throws",
"SQLException",
"{",
"addJoinInfo",
"(",
"JoinType",
".",
"INNER",
",",
"null",
",",
"null",
",",
"joinedQueryBui... | Join with another query builder. This will add into the SQL something close to " INNER JOIN other-table ...".
Either the object associated with the current QueryBuilder or the argument QueryBuilder must have a foreign field
of the other one. An exception will be thrown otherwise.
<p>
<b>NOTE:</b> This will do combine the WHERE statement of the two query builders with a SQL "AND". See
{@link #joinOr(QueryBuilder)}.
</p> | [
"Join",
"with",
"another",
"query",
"builder",
".",
"This",
"will",
"add",
"into",
"the",
"SQL",
"something",
"close",
"to",
"INNER",
"JOIN",
"other",
"-",
"table",
"...",
".",
"Either",
"the",
"object",
"associated",
"with",
"the",
"current",
"QueryBuilder"... | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/QueryBuilder.java#L289-L292 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/QueryBuilder.java | QueryBuilder.addJoinInfo | private void addJoinInfo(JoinType type, String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinWhereOperation operation) throws SQLException {
JoinInfo joinInfo = new JoinInfo(type, joinedQueryBuilder, operation);
if (localColumnName == null) {
matchJoinedFields(joinInfo, joinedQueryBuilder);
} else {
matchJoinedFieldsByName(joinInfo, localColumnName, joinedColumnName, joinedQueryBuilder);
}
if (joinList == null) {
joinList = new ArrayList<JoinInfo>();
}
joinList.add(joinInfo);
} | java | private void addJoinInfo(JoinType type, String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinWhereOperation operation) throws SQLException {
JoinInfo joinInfo = new JoinInfo(type, joinedQueryBuilder, operation);
if (localColumnName == null) {
matchJoinedFields(joinInfo, joinedQueryBuilder);
} else {
matchJoinedFieldsByName(joinInfo, localColumnName, joinedColumnName, joinedQueryBuilder);
}
if (joinList == null) {
joinList = new ArrayList<JoinInfo>();
}
joinList.add(joinInfo);
} | [
"private",
"void",
"addJoinInfo",
"(",
"JoinType",
"type",
",",
"String",
"localColumnName",
",",
"String",
"joinedColumnName",
",",
"QueryBuilder",
"<",
"?",
",",
"?",
">",
"joinedQueryBuilder",
",",
"JoinWhereOperation",
"operation",
")",
"throws",
"SQLException",... | Add join info to the query. This can be called multiple times to join with more than one table. | [
"Add",
"join",
"info",
"to",
"the",
"query",
".",
"This",
"can",
"be",
"called",
"multiple",
"times",
"to",
"join",
"with",
"more",
"than",
"one",
"table",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/QueryBuilder.java#L578-L590 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/TableInfo.java | TableInfo.objectToString | public String objectToString(T object) {
StringBuilder sb = new StringBuilder(64);
sb.append(object.getClass().getSimpleName());
for (FieldType fieldType : fieldTypes) {
sb.append(' ').append(fieldType.getColumnName()).append('=');
try {
sb.append(fieldType.extractJavaFieldValue(object));
} catch (Exception e) {
throw new IllegalStateException("Could not generate toString of field " + fieldType, e);
}
}
return sb.toString();
} | java | public String objectToString(T object) {
StringBuilder sb = new StringBuilder(64);
sb.append(object.getClass().getSimpleName());
for (FieldType fieldType : fieldTypes) {
sb.append(' ').append(fieldType.getColumnName()).append('=');
try {
sb.append(fieldType.extractJavaFieldValue(object));
} catch (Exception e) {
throw new IllegalStateException("Could not generate toString of field " + fieldType, e);
}
}
return sb.toString();
} | [
"public",
"String",
"objectToString",
"(",
"T",
"object",
")",
"{",
"StringBuilder",
"sb",
"=",
"new",
"StringBuilder",
"(",
"64",
")",
";",
"sb",
".",
"append",
"(",
"object",
".",
"getClass",
"(",
")",
".",
"getSimpleName",
"(",
")",
")",
";",
"for",... | Return a string representation of the object. | [
"Return",
"a",
"string",
"representation",
"of",
"the",
"object",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/TableInfo.java#L175-L187 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/misc/VersionUtils.java | VersionUtils.logVersionWarnings | private static void logVersionWarnings(String label1, String version1, String label2, String version2) {
if (version1 == null) {
if (version2 != null) {
warning(null, "Unknown version", " for {}, version for {} is '{}'", new Object[] { label1, label2,
version2 });
}
} else {
if (version2 == null) {
warning(null, "Unknown version", " for {}, version for {} is '{}'", new Object[] { label2, label1,
version1 });
} else if (!version1.equals(version2)) {
warning(null, "Mismatched versions", ": {} is '{}', while {} is '{}'", new Object[] { label1, version1,
label2, version2 });
}
}
} | java | private static void logVersionWarnings(String label1, String version1, String label2, String version2) {
if (version1 == null) {
if (version2 != null) {
warning(null, "Unknown version", " for {}, version for {} is '{}'", new Object[] { label1, label2,
version2 });
}
} else {
if (version2 == null) {
warning(null, "Unknown version", " for {}, version for {} is '{}'", new Object[] { label2, label1,
version1 });
} else if (!version1.equals(version2)) {
warning(null, "Mismatched versions", ": {} is '{}', while {} is '{}'", new Object[] { label1, version1,
label2, version2 });
}
}
} | [
"private",
"static",
"void",
"logVersionWarnings",
"(",
"String",
"label1",
",",
"String",
"version1",
",",
"String",
"label2",
",",
"String",
"version2",
")",
"{",
"if",
"(",
"version1",
"==",
"null",
")",
"{",
"if",
"(",
"version2",
"!=",
"null",
")",
... | Log error information | [
"Log",
"error",
"information"
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/misc/VersionUtils.java#L51-L66 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/StatementBuilder.java | StatementBuilder.prepareStatement | protected MappedPreparedStmt<T, ID> prepareStatement(Long limit, boolean cacheStore) throws SQLException {
List<ArgumentHolder> argList = new ArrayList<ArgumentHolder>();
String statement = buildStatementString(argList);
ArgumentHolder[] selectArgs = argList.toArray(new ArgumentHolder[argList.size()]);
FieldType[] resultFieldTypes = getResultFieldTypes();
FieldType[] argFieldTypes = new FieldType[argList.size()];
for (int selectC = 0; selectC < selectArgs.length; selectC++) {
argFieldTypes[selectC] = selectArgs[selectC].getFieldType();
}
if (!type.isOkForStatementBuilder()) {
throw new IllegalStateException("Building a statement from a " + type + " statement is not allowed");
}
return new MappedPreparedStmt<T, ID>(dao, tableInfo, statement, argFieldTypes, resultFieldTypes, selectArgs,
(databaseType.isLimitSqlSupported() ? null : limit), type, cacheStore);
} | java | protected MappedPreparedStmt<T, ID> prepareStatement(Long limit, boolean cacheStore) throws SQLException {
List<ArgumentHolder> argList = new ArrayList<ArgumentHolder>();
String statement = buildStatementString(argList);
ArgumentHolder[] selectArgs = argList.toArray(new ArgumentHolder[argList.size()]);
FieldType[] resultFieldTypes = getResultFieldTypes();
FieldType[] argFieldTypes = new FieldType[argList.size()];
for (int selectC = 0; selectC < selectArgs.length; selectC++) {
argFieldTypes[selectC] = selectArgs[selectC].getFieldType();
}
if (!type.isOkForStatementBuilder()) {
throw new IllegalStateException("Building a statement from a " + type + " statement is not allowed");
}
return new MappedPreparedStmt<T, ID>(dao, tableInfo, statement, argFieldTypes, resultFieldTypes, selectArgs,
(databaseType.isLimitSqlSupported() ? null : limit), type, cacheStore);
} | [
"protected",
"MappedPreparedStmt",
"<",
"T",
",",
"ID",
">",
"prepareStatement",
"(",
"Long",
"limit",
",",
"boolean",
"cacheStore",
")",
"throws",
"SQLException",
"{",
"List",
"<",
"ArgumentHolder",
">",
"argList",
"=",
"new",
"ArrayList",
"<",
"ArgumentHolder"... | Prepare our statement for the subclasses.
@param limit
Limit for queries. Can be null if none. | [
"Prepare",
"our",
"statement",
"for",
"the",
"subclasses",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/StatementBuilder.java#L73-L87 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/StatementBuilder.java | StatementBuilder.prepareStatementString | public String prepareStatementString() throws SQLException {
List<ArgumentHolder> argList = new ArrayList<ArgumentHolder>();
return buildStatementString(argList);
} | java | public String prepareStatementString() throws SQLException {
List<ArgumentHolder> argList = new ArrayList<ArgumentHolder>();
return buildStatementString(argList);
} | [
"public",
"String",
"prepareStatementString",
"(",
")",
"throws",
"SQLException",
"{",
"List",
"<",
"ArgumentHolder",
">",
"argList",
"=",
"new",
"ArrayList",
"<",
"ArgumentHolder",
">",
"(",
")",
";",
"return",
"buildStatementString",
"(",
"argList",
")",
";",
... | Build and return a string version of the query. If you change the where or make other calls you will need to
re-call this method to re-prepare the query for execution. | [
"Build",
"and",
"return",
"a",
"string",
"version",
"of",
"the",
"query",
".",
"If",
"you",
"change",
"the",
"where",
"or",
"make",
"other",
"calls",
"you",
"will",
"need",
"to",
"re",
"-",
"call",
"this",
"method",
"to",
"re",
"-",
"prepare",
"the",
... | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/StatementBuilder.java#L93-L96 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/StatementBuilder.java | StatementBuilder.appendWhereStatement | protected boolean appendWhereStatement(StringBuilder sb, List<ArgumentHolder> argList, WhereOperation operation)
throws SQLException {
if (where == null) {
return operation == WhereOperation.FIRST;
}
operation.appendBefore(sb);
where.appendSql((addTableName ? getTableName() : null), sb, argList);
operation.appendAfter(sb);
return false;
} | java | protected boolean appendWhereStatement(StringBuilder sb, List<ArgumentHolder> argList, WhereOperation operation)
throws SQLException {
if (where == null) {
return operation == WhereOperation.FIRST;
}
operation.appendBefore(sb);
where.appendSql((addTableName ? getTableName() : null), sb, argList);
operation.appendAfter(sb);
return false;
} | [
"protected",
"boolean",
"appendWhereStatement",
"(",
"StringBuilder",
"sb",
",",
"List",
"<",
"ArgumentHolder",
">",
"argList",
",",
"WhereOperation",
"operation",
")",
"throws",
"SQLException",
"{",
"if",
"(",
"where",
"==",
"null",
")",
"{",
"return",
"operati... | Append the WHERE part of the statement to the StringBuilder. | [
"Append",
"the",
"WHERE",
"part",
"of",
"the",
"statement",
"to",
"the",
"StringBuilder",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/StatementBuilder.java#L145-L154 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/mapped/MappedDeleteCollection.java | MappedDeleteCollection.build | private static <T, ID> MappedDeleteCollection<T, ID> build(Dao<T, ID> dao, TableInfo<T, ID> tableInfo, int dataSize)
throws SQLException {
FieldType idField = tableInfo.getIdField();
if (idField == null) {
throw new SQLException(
"Cannot delete " + tableInfo.getDataClass() + " because it doesn't have an id field defined");
}
StringBuilder sb = new StringBuilder(128);
DatabaseType databaseType = dao.getConnectionSource().getDatabaseType();
appendTableName(databaseType, sb, "DELETE FROM ", tableInfo.getTableName());
FieldType[] argFieldTypes = new FieldType[dataSize];
appendWhereIds(databaseType, idField, sb, dataSize, argFieldTypes);
return new MappedDeleteCollection<T, ID>(dao, tableInfo, sb.toString(), argFieldTypes);
} | java | private static <T, ID> MappedDeleteCollection<T, ID> build(Dao<T, ID> dao, TableInfo<T, ID> tableInfo, int dataSize)
throws SQLException {
FieldType idField = tableInfo.getIdField();
if (idField == null) {
throw new SQLException(
"Cannot delete " + tableInfo.getDataClass() + " because it doesn't have an id field defined");
}
StringBuilder sb = new StringBuilder(128);
DatabaseType databaseType = dao.getConnectionSource().getDatabaseType();
appendTableName(databaseType, sb, "DELETE FROM ", tableInfo.getTableName());
FieldType[] argFieldTypes = new FieldType[dataSize];
appendWhereIds(databaseType, idField, sb, dataSize, argFieldTypes);
return new MappedDeleteCollection<T, ID>(dao, tableInfo, sb.toString(), argFieldTypes);
} | [
"private",
"static",
"<",
"T",
",",
"ID",
">",
"MappedDeleteCollection",
"<",
"T",
",",
"ID",
">",
"build",
"(",
"Dao",
"<",
"T",
",",
"ID",
">",
"dao",
",",
"TableInfo",
"<",
"T",
",",
"ID",
">",
"tableInfo",
",",
"int",
"dataSize",
")",
"throws",... | This is private because the execute is the only method that should be called here. | [
"This",
"is",
"private",
"because",
"the",
"execute",
"is",
"the",
"only",
"method",
"that",
"should",
"be",
"called",
"here",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/mapped/MappedDeleteCollection.java#L63-L76 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/SelectIterator.java | SelectIterator.next | @Override
public T next() {
SQLException sqlException = null;
try {
T result = nextThrow();
if (result != null) {
return result;
}
} catch (SQLException e) {
sqlException = e;
}
// we have to throw if there is no next or on a SQLException
last = null;
closeQuietly();
throw new IllegalStateException("Could not get next result for " + dataClass, sqlException);
} | java | @Override
public T next() {
SQLException sqlException = null;
try {
T result = nextThrow();
if (result != null) {
return result;
}
} catch (SQLException e) {
sqlException = e;
}
// we have to throw if there is no next or on a SQLException
last = null;
closeQuietly();
throw new IllegalStateException("Could not get next result for " + dataClass, sqlException);
} | [
"@",
"Override",
"public",
"T",
"next",
"(",
")",
"{",
"SQLException",
"sqlException",
"=",
"null",
";",
"try",
"{",
"T",
"result",
"=",
"nextThrow",
"(",
")",
";",
"if",
"(",
"result",
"!=",
"null",
")",
"{",
"return",
"result",
";",
"}",
"}",
"ca... | Returns the next object in the table.
@throws IllegalStateException
If there was a problem extracting the object from SQL. | [
"Returns",
"the",
"next",
"object",
"in",
"the",
"table",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/SelectIterator.java#L177-L192 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/TableUtils.java | TableUtils.createTable | public static <T> int createTable(ConnectionSource connectionSource, Class<T> dataClass) throws SQLException {
Dao<T, ?> dao = DaoManager.createDao(connectionSource, dataClass);
return doCreateTable(dao, false);
} | java | public static <T> int createTable(ConnectionSource connectionSource, Class<T> dataClass) throws SQLException {
Dao<T, ?> dao = DaoManager.createDao(connectionSource, dataClass);
return doCreateTable(dao, false);
} | [
"public",
"static",
"<",
"T",
">",
"int",
"createTable",
"(",
"ConnectionSource",
"connectionSource",
",",
"Class",
"<",
"T",
">",
"dataClass",
")",
"throws",
"SQLException",
"{",
"Dao",
"<",
"T",
",",
"?",
">",
"dao",
"=",
"DaoManager",
".",
"createDao",
... | Issue the database statements to create the table associated with a class.
@param connectionSource
Associated connection source.
@param dataClass
The class for which a table will be created.
@return The number of statements executed to do so. | [
"Issue",
"the",
"database",
"statements",
"to",
"create",
"the",
"table",
"associated",
"with",
"a",
"class",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/TableUtils.java#L53-L56 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/TableUtils.java | TableUtils.createTable | public static <T> int createTable(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig)
throws SQLException {
Dao<T, ?> dao = DaoManager.createDao(connectionSource, tableConfig);
return doCreateTable(dao, false);
} | java | public static <T> int createTable(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig)
throws SQLException {
Dao<T, ?> dao = DaoManager.createDao(connectionSource, tableConfig);
return doCreateTable(dao, false);
} | [
"public",
"static",
"<",
"T",
">",
"int",
"createTable",
"(",
"ConnectionSource",
"connectionSource",
",",
"DatabaseTableConfig",
"<",
"T",
">",
"tableConfig",
")",
"throws",
"SQLException",
"{",
"Dao",
"<",
"T",
",",
"?",
">",
"dao",
"=",
"DaoManager",
".",... | Issue the database statements to create the table associated with a table configuration.
@param connectionSource
connectionSource Associated connection source.
@param tableConfig
Hand or spring wired table configuration. If null then the class must have {@link DatabaseField}
annotations.
@return The number of statements executed to do so. | [
"Issue",
"the",
"database",
"statements",
"to",
"create",
"the",
"table",
"associated",
"with",
"a",
"table",
"configuration",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/TableUtils.java#L88-L92 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/TableUtils.java | TableUtils.dropTable | public static <T, ID> int dropTable(ConnectionSource connectionSource, Class<T> dataClass, boolean ignoreErrors)
throws SQLException {
Dao<T, ID> dao = DaoManager.createDao(connectionSource, dataClass);
return dropTable(dao, ignoreErrors);
} | java | public static <T, ID> int dropTable(ConnectionSource connectionSource, Class<T> dataClass, boolean ignoreErrors)
throws SQLException {
Dao<T, ID> dao = DaoManager.createDao(connectionSource, dataClass);
return dropTable(dao, ignoreErrors);
} | [
"public",
"static",
"<",
"T",
",",
"ID",
">",
"int",
"dropTable",
"(",
"ConnectionSource",
"connectionSource",
",",
"Class",
"<",
"T",
">",
"dataClass",
",",
"boolean",
"ignoreErrors",
")",
"throws",
"SQLException",
"{",
"Dao",
"<",
"T",
",",
"ID",
">",
... | Issue the database statements to drop the table associated with a class.
<p>
<b>WARNING:</b> This is [obviously] very destructive and is unrecoverable.
</p>
@param connectionSource
Associated connection source.
@param dataClass
The class for which a table will be dropped.
@param ignoreErrors
If set to true then try each statement regardless of {@link SQLException} thrown previously.
@return The number of statements executed to do so. | [
"Issue",
"the",
"database",
"statements",
"to",
"drop",
"the",
"table",
"associated",
"with",
"a",
"class",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/TableUtils.java#L170-L174 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/TableUtils.java | TableUtils.dropTable | public static <T, ID> int dropTable(Dao<T, ID> dao, boolean ignoreErrors) throws SQLException {
ConnectionSource connectionSource = dao.getConnectionSource();
Class<T> dataClass = dao.getDataClass();
DatabaseType databaseType = connectionSource.getDatabaseType();
if (dao instanceof BaseDaoImpl<?, ?>) {
return doDropTable(databaseType, connectionSource, ((BaseDaoImpl<?, ?>) dao).getTableInfo(), ignoreErrors);
} else {
TableInfo<T, ID> tableInfo = new TableInfo<T, ID>(databaseType, dataClass);
return doDropTable(databaseType, connectionSource, tableInfo, ignoreErrors);
}
} | java | public static <T, ID> int dropTable(Dao<T, ID> dao, boolean ignoreErrors) throws SQLException {
ConnectionSource connectionSource = dao.getConnectionSource();
Class<T> dataClass = dao.getDataClass();
DatabaseType databaseType = connectionSource.getDatabaseType();
if (dao instanceof BaseDaoImpl<?, ?>) {
return doDropTable(databaseType, connectionSource, ((BaseDaoImpl<?, ?>) dao).getTableInfo(), ignoreErrors);
} else {
TableInfo<T, ID> tableInfo = new TableInfo<T, ID>(databaseType, dataClass);
return doDropTable(databaseType, connectionSource, tableInfo, ignoreErrors);
}
} | [
"public",
"static",
"<",
"T",
",",
"ID",
">",
"int",
"dropTable",
"(",
"Dao",
"<",
"T",
",",
"ID",
">",
"dao",
",",
"boolean",
"ignoreErrors",
")",
"throws",
"SQLException",
"{",
"ConnectionSource",
"connectionSource",
"=",
"dao",
".",
"getConnectionSource",... | Issue the database statements to drop the table associated with a dao.
@param dao
Associated dao.
@return The number of statements executed to do so. | [
"Issue",
"the",
"database",
"statements",
"to",
"drop",
"the",
"table",
"associated",
"with",
"a",
"dao",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/TableUtils.java#L183-L193 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/TableUtils.java | TableUtils.dropTable | public static <T, ID> int dropTable(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig,
boolean ignoreErrors) throws SQLException {
DatabaseType databaseType = connectionSource.getDatabaseType();
Dao<T, ID> dao = DaoManager.createDao(connectionSource, tableConfig);
if (dao instanceof BaseDaoImpl<?, ?>) {
return doDropTable(databaseType, connectionSource, ((BaseDaoImpl<?, ?>) dao).getTableInfo(), ignoreErrors);
} else {
tableConfig.extractFieldTypes(databaseType);
TableInfo<T, ID> tableInfo = new TableInfo<T, ID>(databaseType, tableConfig);
return doDropTable(databaseType, connectionSource, tableInfo, ignoreErrors);
}
} | java | public static <T, ID> int dropTable(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig,
boolean ignoreErrors) throws SQLException {
DatabaseType databaseType = connectionSource.getDatabaseType();
Dao<T, ID> dao = DaoManager.createDao(connectionSource, tableConfig);
if (dao instanceof BaseDaoImpl<?, ?>) {
return doDropTable(databaseType, connectionSource, ((BaseDaoImpl<?, ?>) dao).getTableInfo(), ignoreErrors);
} else {
tableConfig.extractFieldTypes(databaseType);
TableInfo<T, ID> tableInfo = new TableInfo<T, ID>(databaseType, tableConfig);
return doDropTable(databaseType, connectionSource, tableInfo, ignoreErrors);
}
} | [
"public",
"static",
"<",
"T",
",",
"ID",
">",
"int",
"dropTable",
"(",
"ConnectionSource",
"connectionSource",
",",
"DatabaseTableConfig",
"<",
"T",
">",
"tableConfig",
",",
"boolean",
"ignoreErrors",
")",
"throws",
"SQLException",
"{",
"DatabaseType",
"databaseTy... | Issue the database statements to drop the table associated with a table configuration.
<p>
<b>WARNING:</b> This is [obviously] very destructive and is unrecoverable.
</p>
@param connectionSource
Associated connection source.
@param tableConfig
Hand or spring wired table configuration. If null then the class must have {@link DatabaseField}
annotations.
@param ignoreErrors
If set to true then try each statement regardless of {@link SQLException} thrown previously.
@return The number of statements executed to do so. | [
"Issue",
"the",
"database",
"statements",
"to",
"drop",
"the",
"table",
"associated",
"with",
"a",
"table",
"configuration",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/TableUtils.java#L211-L222 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/TableUtils.java | TableUtils.addDropTableStatements | private static <T, ID> void addDropTableStatements(DatabaseType databaseType, TableInfo<T, ID> tableInfo,
List<String> statements, boolean logDetails) {
List<String> statementsBefore = new ArrayList<String>();
List<String> statementsAfter = new ArrayList<String>();
for (FieldType fieldType : tableInfo.getFieldTypes()) {
databaseType.dropColumnArg(fieldType, statementsBefore, statementsAfter);
}
StringBuilder sb = new StringBuilder(64);
if (logDetails) {
logger.info("dropping table '{}'", tableInfo.getTableName());
}
sb.append("DROP TABLE ");
databaseType.appendEscapedEntityName(sb, tableInfo.getTableName());
sb.append(' ');
statements.addAll(statementsBefore);
statements.add(sb.toString());
statements.addAll(statementsAfter);
} | java | private static <T, ID> void addDropTableStatements(DatabaseType databaseType, TableInfo<T, ID> tableInfo,
List<String> statements, boolean logDetails) {
List<String> statementsBefore = new ArrayList<String>();
List<String> statementsAfter = new ArrayList<String>();
for (FieldType fieldType : tableInfo.getFieldTypes()) {
databaseType.dropColumnArg(fieldType, statementsBefore, statementsAfter);
}
StringBuilder sb = new StringBuilder(64);
if (logDetails) {
logger.info("dropping table '{}'", tableInfo.getTableName());
}
sb.append("DROP TABLE ");
databaseType.appendEscapedEntityName(sb, tableInfo.getTableName());
sb.append(' ');
statements.addAll(statementsBefore);
statements.add(sb.toString());
statements.addAll(statementsAfter);
} | [
"private",
"static",
"<",
"T",
",",
"ID",
">",
"void",
"addDropTableStatements",
"(",
"DatabaseType",
"databaseType",
",",
"TableInfo",
"<",
"T",
",",
"ID",
">",
"tableInfo",
",",
"List",
"<",
"String",
">",
"statements",
",",
"boolean",
"logDetails",
")",
... | Generate and return the list of statements to drop a database table. | [
"Generate",
"and",
"return",
"the",
"list",
"of",
"statements",
"to",
"drop",
"a",
"database",
"table",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/TableUtils.java#L319-L336 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/TableUtils.java | TableUtils.addCreateTableStatements | private static <T, ID> void addCreateTableStatements(DatabaseType databaseType, TableInfo<T, ID> tableInfo,
List<String> statements, List<String> queriesAfter, boolean ifNotExists, boolean logDetails)
throws SQLException {
StringBuilder sb = new StringBuilder(256);
if (logDetails) {
logger.info("creating table '{}'", tableInfo.getTableName());
}
sb.append("CREATE TABLE ");
if (ifNotExists && databaseType.isCreateIfNotExistsSupported()) {
sb.append("IF NOT EXISTS ");
}
databaseType.appendEscapedEntityName(sb, tableInfo.getTableName());
sb.append(" (");
List<String> additionalArgs = new ArrayList<String>();
List<String> statementsBefore = new ArrayList<String>();
List<String> statementsAfter = new ArrayList<String>();
// our statement will be set here later
boolean first = true;
for (FieldType fieldType : tableInfo.getFieldTypes()) {
// skip foreign collections
if (fieldType.isForeignCollection()) {
continue;
} else if (first) {
first = false;
} else {
sb.append(", ");
}
String columnDefinition = fieldType.getColumnDefinition();
if (columnDefinition == null) {
// we have to call back to the database type for the specific create syntax
databaseType.appendColumnArg(tableInfo.getTableName(), sb, fieldType, additionalArgs, statementsBefore,
statementsAfter, queriesAfter);
} else {
// hand defined field
databaseType.appendEscapedEntityName(sb, fieldType.getColumnName());
sb.append(' ').append(columnDefinition).append(' ');
}
}
// add any sql that sets any primary key fields
databaseType.addPrimaryKeySql(tableInfo.getFieldTypes(), additionalArgs, statementsBefore, statementsAfter,
queriesAfter);
// add any sql that sets any unique fields
databaseType.addUniqueComboSql(tableInfo.getFieldTypes(), additionalArgs, statementsBefore, statementsAfter,
queriesAfter);
for (String arg : additionalArgs) {
// we will have spat out one argument already so we don't have to do the first dance
sb.append(", ").append(arg);
}
sb.append(") ");
databaseType.appendCreateTableSuffix(sb);
statements.addAll(statementsBefore);
statements.add(sb.toString());
statements.addAll(statementsAfter);
addCreateIndexStatements(databaseType, tableInfo, statements, ifNotExists, false, logDetails);
addCreateIndexStatements(databaseType, tableInfo, statements, ifNotExists, true, logDetails);
} | java | private static <T, ID> void addCreateTableStatements(DatabaseType databaseType, TableInfo<T, ID> tableInfo,
List<String> statements, List<String> queriesAfter, boolean ifNotExists, boolean logDetails)
throws SQLException {
StringBuilder sb = new StringBuilder(256);
if (logDetails) {
logger.info("creating table '{}'", tableInfo.getTableName());
}
sb.append("CREATE TABLE ");
if (ifNotExists && databaseType.isCreateIfNotExistsSupported()) {
sb.append("IF NOT EXISTS ");
}
databaseType.appendEscapedEntityName(sb, tableInfo.getTableName());
sb.append(" (");
List<String> additionalArgs = new ArrayList<String>();
List<String> statementsBefore = new ArrayList<String>();
List<String> statementsAfter = new ArrayList<String>();
// our statement will be set here later
boolean first = true;
for (FieldType fieldType : tableInfo.getFieldTypes()) {
// skip foreign collections
if (fieldType.isForeignCollection()) {
continue;
} else if (first) {
first = false;
} else {
sb.append(", ");
}
String columnDefinition = fieldType.getColumnDefinition();
if (columnDefinition == null) {
// we have to call back to the database type for the specific create syntax
databaseType.appendColumnArg(tableInfo.getTableName(), sb, fieldType, additionalArgs, statementsBefore,
statementsAfter, queriesAfter);
} else {
// hand defined field
databaseType.appendEscapedEntityName(sb, fieldType.getColumnName());
sb.append(' ').append(columnDefinition).append(' ');
}
}
// add any sql that sets any primary key fields
databaseType.addPrimaryKeySql(tableInfo.getFieldTypes(), additionalArgs, statementsBefore, statementsAfter,
queriesAfter);
// add any sql that sets any unique fields
databaseType.addUniqueComboSql(tableInfo.getFieldTypes(), additionalArgs, statementsBefore, statementsAfter,
queriesAfter);
for (String arg : additionalArgs) {
// we will have spat out one argument already so we don't have to do the first dance
sb.append(", ").append(arg);
}
sb.append(") ");
databaseType.appendCreateTableSuffix(sb);
statements.addAll(statementsBefore);
statements.add(sb.toString());
statements.addAll(statementsAfter);
addCreateIndexStatements(databaseType, tableInfo, statements, ifNotExists, false, logDetails);
addCreateIndexStatements(databaseType, tableInfo, statements, ifNotExists, true, logDetails);
} | [
"private",
"static",
"<",
"T",
",",
"ID",
">",
"void",
"addCreateTableStatements",
"(",
"DatabaseType",
"databaseType",
",",
"TableInfo",
"<",
"T",
",",
"ID",
">",
"tableInfo",
",",
"List",
"<",
"String",
">",
"statements",
",",
"List",
"<",
"String",
">",... | Generate and return the list of statements to create a database table and any associated features. | [
"Generate",
"and",
"return",
"the",
"list",
"of",
"statements",
"to",
"create",
"a",
"database",
"table",
"and",
"any",
"associated",
"features",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/TableUtils.java#L440-L495 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/FieldType.java | FieldType.assignField | public void assignField(ConnectionSource connectionSource, Object data, Object val, boolean parentObject,
ObjectCache objectCache) throws SQLException {
if (logger.isLevelEnabled(Level.TRACE)) {
logger.trace("assiging from data {}, val {}: {}", (data == null ? "null" : data.getClass()),
(val == null ? "null" : val.getClass()), val);
}
// if this is a foreign object then val is the foreign object's id val
if (foreignRefField != null && val != null) {
// get the current field value which is the foreign-id
Object foreignRef = extractJavaFieldValue(data);
/*
* See if we don't need to create a new foreign object. If we are refreshing and the id field has not
* changed then there is no need to create a new foreign object and maybe lose previously refreshed field
* information.
*/
if (foreignRef != null && foreignRef.equals(val)) {
return;
}
// awhitlock: raised as OrmLite issue: bug #122
Object cachedVal;
ObjectCache foreignCache = foreignDao.getObjectCache();
if (foreignCache == null) {
cachedVal = null;
} else {
cachedVal = foreignCache.get(getType(), val);
}
if (cachedVal != null) {
val = cachedVal;
} else if (!parentObject) {
// the value we are to assign to our field is now the foreign object itself
val = createForeignObject(connectionSource, val, objectCache);
}
}
if (fieldSetMethod == null) {
try {
field.set(data, val);
} catch (IllegalArgumentException e) {
if (val == null) {
throw SqlExceptionUtil.create("Could not assign object '" + val + "' to field " + this, e);
} else {
throw SqlExceptionUtil.create(
"Could not assign object '" + val + "' of type " + val.getClass() + " to field " + this, e);
}
} catch (IllegalAccessException e) {
throw SqlExceptionUtil.create(
"Could not assign object '" + val + "' of type " + val.getClass() + "' to field " + this, e);
}
} else {
try {
fieldSetMethod.invoke(data, val);
} catch (Exception e) {
throw SqlExceptionUtil
.create("Could not call " + fieldSetMethod + " on object with '" + val + "' for " + this, e);
}
}
} | java | public void assignField(ConnectionSource connectionSource, Object data, Object val, boolean parentObject,
ObjectCache objectCache) throws SQLException {
if (logger.isLevelEnabled(Level.TRACE)) {
logger.trace("assiging from data {}, val {}: {}", (data == null ? "null" : data.getClass()),
(val == null ? "null" : val.getClass()), val);
}
// if this is a foreign object then val is the foreign object's id val
if (foreignRefField != null && val != null) {
// get the current field value which is the foreign-id
Object foreignRef = extractJavaFieldValue(data);
/*
* See if we don't need to create a new foreign object. If we are refreshing and the id field has not
* changed then there is no need to create a new foreign object and maybe lose previously refreshed field
* information.
*/
if (foreignRef != null && foreignRef.equals(val)) {
return;
}
// awhitlock: raised as OrmLite issue: bug #122
Object cachedVal;
ObjectCache foreignCache = foreignDao.getObjectCache();
if (foreignCache == null) {
cachedVal = null;
} else {
cachedVal = foreignCache.get(getType(), val);
}
if (cachedVal != null) {
val = cachedVal;
} else if (!parentObject) {
// the value we are to assign to our field is now the foreign object itself
val = createForeignObject(connectionSource, val, objectCache);
}
}
if (fieldSetMethod == null) {
try {
field.set(data, val);
} catch (IllegalArgumentException e) {
if (val == null) {
throw SqlExceptionUtil.create("Could not assign object '" + val + "' to field " + this, e);
} else {
throw SqlExceptionUtil.create(
"Could not assign object '" + val + "' of type " + val.getClass() + " to field " + this, e);
}
} catch (IllegalAccessException e) {
throw SqlExceptionUtil.create(
"Could not assign object '" + val + "' of type " + val.getClass() + "' to field " + this, e);
}
} else {
try {
fieldSetMethod.invoke(data, val);
} catch (Exception e) {
throw SqlExceptionUtil
.create("Could not call " + fieldSetMethod + " on object with '" + val + "' for " + this, e);
}
}
} | [
"public",
"void",
"assignField",
"(",
"ConnectionSource",
"connectionSource",
",",
"Object",
"data",
",",
"Object",
"val",
",",
"boolean",
"parentObject",
",",
"ObjectCache",
"objectCache",
")",
"throws",
"SQLException",
"{",
"if",
"(",
"logger",
".",
"isLevelEnab... | Assign to the data object the val corresponding to the fieldType. | [
"Assign",
"to",
"the",
"data",
"object",
"the",
"val",
"corresponding",
"to",
"the",
"fieldType",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/FieldType.java#L525-L582 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/FieldType.java | FieldType.assignIdValue | public Object assignIdValue(ConnectionSource connectionSource, Object data, Number val, ObjectCache objectCache)
throws SQLException {
Object idVal = dataPersister.convertIdNumber(val);
if (idVal == null) {
throw new SQLException("Invalid class " + dataPersister + " for sequence-id " + this);
} else {
assignField(connectionSource, data, idVal, false, objectCache);
return idVal;
}
} | java | public Object assignIdValue(ConnectionSource connectionSource, Object data, Number val, ObjectCache objectCache)
throws SQLException {
Object idVal = dataPersister.convertIdNumber(val);
if (idVal == null) {
throw new SQLException("Invalid class " + dataPersister + " for sequence-id " + this);
} else {
assignField(connectionSource, data, idVal, false, objectCache);
return idVal;
}
} | [
"public",
"Object",
"assignIdValue",
"(",
"ConnectionSource",
"connectionSource",
",",
"Object",
"data",
",",
"Number",
"val",
",",
"ObjectCache",
"objectCache",
")",
"throws",
"SQLException",
"{",
"Object",
"idVal",
"=",
"dataPersister",
".",
"convertIdNumber",
"("... | Assign an ID value to this field. | [
"Assign",
"an",
"ID",
"value",
"to",
"this",
"field",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/FieldType.java#L587-L596 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/FieldType.java | FieldType.extractRawJavaFieldValue | public <FV> FV extractRawJavaFieldValue(Object object) throws SQLException {
Object val;
if (fieldGetMethod == null) {
try {
// field object may not be a T yet
val = field.get(object);
} catch (Exception e) {
throw SqlExceptionUtil.create("Could not get field value for " + this, e);
}
} else {
try {
val = fieldGetMethod.invoke(object);
} catch (Exception e) {
throw SqlExceptionUtil.create("Could not call " + fieldGetMethod + " for " + this, e);
}
}
@SuppressWarnings("unchecked")
FV converted = (FV) val;
return converted;
} | java | public <FV> FV extractRawJavaFieldValue(Object object) throws SQLException {
Object val;
if (fieldGetMethod == null) {
try {
// field object may not be a T yet
val = field.get(object);
} catch (Exception e) {
throw SqlExceptionUtil.create("Could not get field value for " + this, e);
}
} else {
try {
val = fieldGetMethod.invoke(object);
} catch (Exception e) {
throw SqlExceptionUtil.create("Could not call " + fieldGetMethod + " for " + this, e);
}
}
@SuppressWarnings("unchecked")
FV converted = (FV) val;
return converted;
} | [
"public",
"<",
"FV",
">",
"FV",
"extractRawJavaFieldValue",
"(",
"Object",
"object",
")",
"throws",
"SQLException",
"{",
"Object",
"val",
";",
"if",
"(",
"fieldGetMethod",
"==",
"null",
")",
"{",
"try",
"{",
"// field object may not be a T yet",
"val",
"=",
"f... | Return the value from the field in the object that is defined by this FieldType. | [
"Return",
"the",
"value",
"from",
"the",
"field",
"in",
"the",
"object",
"that",
"is",
"defined",
"by",
"this",
"FieldType",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/FieldType.java#L601-L621 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/FieldType.java | FieldType.extractJavaFieldValue | public Object extractJavaFieldValue(Object object) throws SQLException {
Object val = extractRawJavaFieldValue(object);
// if this is a foreign object then we want its reference field
if (foreignRefField != null && val != null) {
val = foreignRefField.extractRawJavaFieldValue(val);
}
return val;
} | java | public Object extractJavaFieldValue(Object object) throws SQLException {
Object val = extractRawJavaFieldValue(object);
// if this is a foreign object then we want its reference field
if (foreignRefField != null && val != null) {
val = foreignRefField.extractRawJavaFieldValue(val);
}
return val;
} | [
"public",
"Object",
"extractJavaFieldValue",
"(",
"Object",
"object",
")",
"throws",
"SQLException",
"{",
"Object",
"val",
"=",
"extractRawJavaFieldValue",
"(",
"object",
")",
";",
"// if this is a foreign object then we want its reference field",
"if",
"(",
"foreignRefFiel... | Return the value from the field in the object that is defined by this FieldType. If the field is a foreign object
then the ID of the field is returned instead. | [
"Return",
"the",
"value",
"from",
"the",
"field",
"in",
"the",
"object",
"that",
"is",
"defined",
"by",
"this",
"FieldType",
".",
"If",
"the",
"field",
"is",
"a",
"foreign",
"object",
"then",
"the",
"ID",
"of",
"the",
"field",
"is",
"returned",
"instead"... | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/FieldType.java#L627-L637 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/FieldType.java | FieldType.convertJavaFieldToSqlArgValue | public Object convertJavaFieldToSqlArgValue(Object fieldVal) throws SQLException {
/*
* Limitation here. Some people may want to override the null with their own value in the converter but we
* currently don't allow that. Specifying a default value I guess is a better mechanism.
*/
if (fieldVal == null) {
return null;
} else {
return fieldConverter.javaToSqlArg(this, fieldVal);
}
} | java | public Object convertJavaFieldToSqlArgValue(Object fieldVal) throws SQLException {
/*
* Limitation here. Some people may want to override the null with their own value in the converter but we
* currently don't allow that. Specifying a default value I guess is a better mechanism.
*/
if (fieldVal == null) {
return null;
} else {
return fieldConverter.javaToSqlArg(this, fieldVal);
}
} | [
"public",
"Object",
"convertJavaFieldToSqlArgValue",
"(",
"Object",
"fieldVal",
")",
"throws",
"SQLException",
"{",
"/*\n\t\t * Limitation here. Some people may want to override the null with their own value in the converter but we\n\t\t * currently don't allow that. Specifying a default value I... | Convert a field value to something suitable to be stored in the database. | [
"Convert",
"a",
"field",
"value",
"to",
"something",
"suitable",
"to",
"be",
"stored",
"in",
"the",
"database",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/FieldType.java#L649-L659 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/FieldType.java | FieldType.convertStringToJavaField | public Object convertStringToJavaField(String value, int columnPos) throws SQLException {
if (value == null) {
return null;
} else {
return fieldConverter.resultStringToJava(this, value, columnPos);
}
} | java | public Object convertStringToJavaField(String value, int columnPos) throws SQLException {
if (value == null) {
return null;
} else {
return fieldConverter.resultStringToJava(this, value, columnPos);
}
} | [
"public",
"Object",
"convertStringToJavaField",
"(",
"String",
"value",
",",
"int",
"columnPos",
")",
"throws",
"SQLException",
"{",
"if",
"(",
"value",
"==",
"null",
")",
"{",
"return",
"null",
";",
"}",
"else",
"{",
"return",
"fieldConverter",
".",
"result... | Convert a string value into the appropriate Java field value. | [
"Convert",
"a",
"string",
"value",
"into",
"the",
"appropriate",
"Java",
"field",
"value",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/FieldType.java#L664-L670 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/FieldType.java | FieldType.moveToNextValue | public Object moveToNextValue(Object val) throws SQLException {
if (dataPersister == null) {
return null;
} else {
return dataPersister.moveToNextValue(val);
}
} | java | public Object moveToNextValue(Object val) throws SQLException {
if (dataPersister == null) {
return null;
} else {
return dataPersister.moveToNextValue(val);
}
} | [
"public",
"Object",
"moveToNextValue",
"(",
"Object",
"val",
")",
"throws",
"SQLException",
"{",
"if",
"(",
"dataPersister",
"==",
"null",
")",
"{",
"return",
"null",
";",
"}",
"else",
"{",
"return",
"dataPersister",
".",
"moveToNextValue",
"(",
"val",
")",
... | Move the SQL value to the next one for version processing. | [
"Move",
"the",
"SQL",
"value",
"to",
"the",
"next",
"one",
"for",
"version",
"processing",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/FieldType.java#L675-L681 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/FieldType.java | FieldType.buildForeignCollection | public <FT, FID> BaseForeignCollection<FT, FID> buildForeignCollection(Object parent, FID id) throws SQLException {
// this can happen if we have a foreign-auto-refresh scenario
if (foreignFieldType == null) {
return null;
}
@SuppressWarnings("unchecked")
Dao<FT, FID> castDao = (Dao<FT, FID>) foreignDao;
if (!fieldConfig.isForeignCollectionEager()) {
// we know this won't go recursive so no need for the counters
return new LazyForeignCollection<FT, FID>(castDao, parent, id, foreignFieldType,
fieldConfig.getForeignCollectionOrderColumnName(), fieldConfig.isForeignCollectionOrderAscending());
}
// try not to create level counter objects unless we have to
LevelCounters levelCounters = threadLevelCounters.get();
if (levelCounters == null) {
if (fieldConfig.getForeignCollectionMaxEagerLevel() == 0) {
// then return a lazy collection instead
return new LazyForeignCollection<FT, FID>(castDao, parent, id, foreignFieldType,
fieldConfig.getForeignCollectionOrderColumnName(),
fieldConfig.isForeignCollectionOrderAscending());
}
levelCounters = new LevelCounters();
threadLevelCounters.set(levelCounters);
}
if (levelCounters.foreignCollectionLevel == 0) {
levelCounters.foreignCollectionLevelMax = fieldConfig.getForeignCollectionMaxEagerLevel();
}
// are we over our level limit?
if (levelCounters.foreignCollectionLevel >= levelCounters.foreignCollectionLevelMax) {
// then return a lazy collection instead
return new LazyForeignCollection<FT, FID>(castDao, parent, id, foreignFieldType,
fieldConfig.getForeignCollectionOrderColumnName(), fieldConfig.isForeignCollectionOrderAscending());
}
levelCounters.foreignCollectionLevel++;
try {
return new EagerForeignCollection<FT, FID>(castDao, parent, id, foreignFieldType,
fieldConfig.getForeignCollectionOrderColumnName(), fieldConfig.isForeignCollectionOrderAscending());
} finally {
levelCounters.foreignCollectionLevel--;
}
} | java | public <FT, FID> BaseForeignCollection<FT, FID> buildForeignCollection(Object parent, FID id) throws SQLException {
// this can happen if we have a foreign-auto-refresh scenario
if (foreignFieldType == null) {
return null;
}
@SuppressWarnings("unchecked")
Dao<FT, FID> castDao = (Dao<FT, FID>) foreignDao;
if (!fieldConfig.isForeignCollectionEager()) {
// we know this won't go recursive so no need for the counters
return new LazyForeignCollection<FT, FID>(castDao, parent, id, foreignFieldType,
fieldConfig.getForeignCollectionOrderColumnName(), fieldConfig.isForeignCollectionOrderAscending());
}
// try not to create level counter objects unless we have to
LevelCounters levelCounters = threadLevelCounters.get();
if (levelCounters == null) {
if (fieldConfig.getForeignCollectionMaxEagerLevel() == 0) {
// then return a lazy collection instead
return new LazyForeignCollection<FT, FID>(castDao, parent, id, foreignFieldType,
fieldConfig.getForeignCollectionOrderColumnName(),
fieldConfig.isForeignCollectionOrderAscending());
}
levelCounters = new LevelCounters();
threadLevelCounters.set(levelCounters);
}
if (levelCounters.foreignCollectionLevel == 0) {
levelCounters.foreignCollectionLevelMax = fieldConfig.getForeignCollectionMaxEagerLevel();
}
// are we over our level limit?
if (levelCounters.foreignCollectionLevel >= levelCounters.foreignCollectionLevelMax) {
// then return a lazy collection instead
return new LazyForeignCollection<FT, FID>(castDao, parent, id, foreignFieldType,
fieldConfig.getForeignCollectionOrderColumnName(), fieldConfig.isForeignCollectionOrderAscending());
}
levelCounters.foreignCollectionLevel++;
try {
return new EagerForeignCollection<FT, FID>(castDao, parent, id, foreignFieldType,
fieldConfig.getForeignCollectionOrderColumnName(), fieldConfig.isForeignCollectionOrderAscending());
} finally {
levelCounters.foreignCollectionLevel--;
}
} | [
"public",
"<",
"FT",
",",
"FID",
">",
"BaseForeignCollection",
"<",
"FT",
",",
"FID",
">",
"buildForeignCollection",
"(",
"Object",
"parent",
",",
"FID",
"id",
")",
"throws",
"SQLException",
"{",
"// this can happen if we have a foreign-auto-refresh scenario",
"if",
... | Build and return a foreign collection based on the field settings that matches the id argument. This can return
null in certain circumstances.
@param parent
The parent object that we will set on each item in the collection.
@param id
The id of the foreign object we will look for. This can be null if we are creating an empty
collection. | [
"Build",
"and",
"return",
"a",
"foreign",
"collection",
"based",
"on",
"the",
"field",
"settings",
"that",
"matches",
"the",
"id",
"argument",
".",
"This",
"can",
"return",
"null",
"in",
"certain",
"circumstances",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/FieldType.java#L781-L823 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/FieldType.java | FieldType.getFieldValueIfNotDefault | public <FV> FV getFieldValueIfNotDefault(Object object) throws SQLException {
@SuppressWarnings("unchecked")
FV fieldValue = (FV) extractJavaFieldValue(object);
if (isFieldValueDefault(fieldValue)) {
return null;
} else {
return fieldValue;
}
} | java | public <FV> FV getFieldValueIfNotDefault(Object object) throws SQLException {
@SuppressWarnings("unchecked")
FV fieldValue = (FV) extractJavaFieldValue(object);
if (isFieldValueDefault(fieldValue)) {
return null;
} else {
return fieldValue;
}
} | [
"public",
"<",
"FV",
">",
"FV",
"getFieldValueIfNotDefault",
"(",
"Object",
"object",
")",
"throws",
"SQLException",
"{",
"@",
"SuppressWarnings",
"(",
"\"unchecked\"",
")",
"FV",
"fieldValue",
"=",
"(",
"FV",
")",
"extractJavaFieldValue",
"(",
"object",
")",
... | Return the value of field in the data argument if it is not the default value for the class. If it is the default
then null is returned. | [
"Return",
"the",
"value",
"of",
"field",
"in",
"the",
"data",
"argument",
"if",
"it",
"is",
"not",
"the",
"default",
"value",
"for",
"the",
"class",
".",
"If",
"it",
"is",
"the",
"default",
"then",
"null",
"is",
"returned",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/FieldType.java#L927-L935 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/FieldType.java | FieldType.isObjectsFieldValueDefault | public boolean isObjectsFieldValueDefault(Object object) throws SQLException {
Object fieldValue = extractJavaFieldValue(object);
return isFieldValueDefault(fieldValue);
} | java | public boolean isObjectsFieldValueDefault(Object object) throws SQLException {
Object fieldValue = extractJavaFieldValue(object);
return isFieldValueDefault(fieldValue);
} | [
"public",
"boolean",
"isObjectsFieldValueDefault",
"(",
"Object",
"object",
")",
"throws",
"SQLException",
"{",
"Object",
"fieldValue",
"=",
"extractJavaFieldValue",
"(",
"object",
")",
";",
"return",
"isFieldValueDefault",
"(",
"fieldValue",
")",
";",
"}"
] | Return whether or not the data object has a default value passed for this field of this type. | [
"Return",
"whether",
"or",
"not",
"the",
"data",
"object",
"has",
"a",
"default",
"value",
"passed",
"for",
"this",
"field",
"of",
"this",
"type",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/FieldType.java#L940-L943 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/FieldType.java | FieldType.getJavaDefaultValueDefault | public Object getJavaDefaultValueDefault() {
if (field.getType() == boolean.class) {
return DEFAULT_VALUE_BOOLEAN;
} else if (field.getType() == byte.class || field.getType() == Byte.class) {
return DEFAULT_VALUE_BYTE;
} else if (field.getType() == char.class || field.getType() == Character.class) {
return DEFAULT_VALUE_CHAR;
} else if (field.getType() == short.class || field.getType() == Short.class) {
return DEFAULT_VALUE_SHORT;
} else if (field.getType() == int.class || field.getType() == Integer.class) {
return DEFAULT_VALUE_INT;
} else if (field.getType() == long.class || field.getType() == Long.class) {
return DEFAULT_VALUE_LONG;
} else if (field.getType() == float.class || field.getType() == Float.class) {
return DEFAULT_VALUE_FLOAT;
} else if (field.getType() == double.class || field.getType() == Double.class) {
return DEFAULT_VALUE_DOUBLE;
} else {
return null;
}
} | java | public Object getJavaDefaultValueDefault() {
if (field.getType() == boolean.class) {
return DEFAULT_VALUE_BOOLEAN;
} else if (field.getType() == byte.class || field.getType() == Byte.class) {
return DEFAULT_VALUE_BYTE;
} else if (field.getType() == char.class || field.getType() == Character.class) {
return DEFAULT_VALUE_CHAR;
} else if (field.getType() == short.class || field.getType() == Short.class) {
return DEFAULT_VALUE_SHORT;
} else if (field.getType() == int.class || field.getType() == Integer.class) {
return DEFAULT_VALUE_INT;
} else if (field.getType() == long.class || field.getType() == Long.class) {
return DEFAULT_VALUE_LONG;
} else if (field.getType() == float.class || field.getType() == Float.class) {
return DEFAULT_VALUE_FLOAT;
} else if (field.getType() == double.class || field.getType() == Double.class) {
return DEFAULT_VALUE_DOUBLE;
} else {
return null;
}
} | [
"public",
"Object",
"getJavaDefaultValueDefault",
"(",
")",
"{",
"if",
"(",
"field",
".",
"getType",
"(",
")",
"==",
"boolean",
".",
"class",
")",
"{",
"return",
"DEFAULT_VALUE_BOOLEAN",
";",
"}",
"else",
"if",
"(",
"field",
".",
"getType",
"(",
")",
"==... | Return whether or not the field value passed in is the default value for the type of the field. Null will return
true. | [
"Return",
"whether",
"or",
"not",
"the",
"field",
"value",
"passed",
"in",
"is",
"the",
"default",
"value",
"for",
"the",
"type",
"of",
"the",
"field",
".",
"Null",
"will",
"return",
"true",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/FieldType.java#L949-L969 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/FieldType.java | FieldType.createForeignShell | private <FT, FID> FT createForeignShell(ConnectionSource connectionSource, Object val, ObjectCache objectCache)
throws SQLException {
@SuppressWarnings("unchecked")
Dao<FT, FID> castDao = (Dao<FT, FID>) foreignDao;
FT foreignObject = castDao.createObjectInstance();
foreignIdField.assignField(connectionSource, foreignObject, val, false, objectCache);
return foreignObject;
} | java | private <FT, FID> FT createForeignShell(ConnectionSource connectionSource, Object val, ObjectCache objectCache)
throws SQLException {
@SuppressWarnings("unchecked")
Dao<FT, FID> castDao = (Dao<FT, FID>) foreignDao;
FT foreignObject = castDao.createObjectInstance();
foreignIdField.assignField(connectionSource, foreignObject, val, false, objectCache);
return foreignObject;
} | [
"private",
"<",
"FT",
",",
"FID",
">",
"FT",
"createForeignShell",
"(",
"ConnectionSource",
"connectionSource",
",",
"Object",
"val",
",",
"ObjectCache",
"objectCache",
")",
"throws",
"SQLException",
"{",
"@",
"SuppressWarnings",
"(",
"\"unchecked\"",
")",
"Dao",
... | Create a shell object and assign its id field. | [
"Create",
"a",
"shell",
"object",
"and",
"assign",
"its",
"id",
"field",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/FieldType.java#L1084-L1091 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/FieldType.java | FieldType.findForeignFieldType | private FieldType findForeignFieldType(Class<?> clazz, Class<?> foreignClass, Dao<?, ?> foreignDao)
throws SQLException {
String foreignColumnName = fieldConfig.getForeignCollectionForeignFieldName();
for (FieldType fieldType : foreignDao.getTableInfo().getFieldTypes()) {
if (fieldType.getType() == foreignClass
&& (foreignColumnName == null || fieldType.getField().getName().equals(foreignColumnName))) {
if (!fieldType.fieldConfig.isForeign() && !fieldType.fieldConfig.isForeignAutoRefresh()) {
// this may never be reached
throw new SQLException("Foreign collection object " + clazz + " for field '" + field.getName()
+ "' contains a field of class " + foreignClass + " but it's not foreign");
}
return fieldType;
}
}
// build our complex error message
StringBuilder sb = new StringBuilder();
sb.append("Foreign collection class ").append(clazz.getName());
sb.append(" for field '").append(field.getName()).append("' column-name does not contain a foreign field");
if (foreignColumnName != null) {
sb.append(" named '").append(foreignColumnName).append('\'');
}
sb.append(" of class ").append(foreignClass.getName());
throw new SQLException(sb.toString());
} | java | private FieldType findForeignFieldType(Class<?> clazz, Class<?> foreignClass, Dao<?, ?> foreignDao)
throws SQLException {
String foreignColumnName = fieldConfig.getForeignCollectionForeignFieldName();
for (FieldType fieldType : foreignDao.getTableInfo().getFieldTypes()) {
if (fieldType.getType() == foreignClass
&& (foreignColumnName == null || fieldType.getField().getName().equals(foreignColumnName))) {
if (!fieldType.fieldConfig.isForeign() && !fieldType.fieldConfig.isForeignAutoRefresh()) {
// this may never be reached
throw new SQLException("Foreign collection object " + clazz + " for field '" + field.getName()
+ "' contains a field of class " + foreignClass + " but it's not foreign");
}
return fieldType;
}
}
// build our complex error message
StringBuilder sb = new StringBuilder();
sb.append("Foreign collection class ").append(clazz.getName());
sb.append(" for field '").append(field.getName()).append("' column-name does not contain a foreign field");
if (foreignColumnName != null) {
sb.append(" named '").append(foreignColumnName).append('\'');
}
sb.append(" of class ").append(foreignClass.getName());
throw new SQLException(sb.toString());
} | [
"private",
"FieldType",
"findForeignFieldType",
"(",
"Class",
"<",
"?",
">",
"clazz",
",",
"Class",
"<",
"?",
">",
"foreignClass",
",",
"Dao",
"<",
"?",
",",
"?",
">",
"foreignDao",
")",
"throws",
"SQLException",
"{",
"String",
"foreignColumnName",
"=",
"f... | If we have a class Foo with a collection of Bar's then we go through Bar's DAO looking for a Foo field. We need
this field to build the query that is able to find all Bar's that have foo_id that matches our id. | [
"If",
"we",
"have",
"a",
"class",
"Foo",
"with",
"a",
"collection",
"of",
"Bar",
"s",
"then",
"we",
"go",
"through",
"Bar",
"s",
"DAO",
"looking",
"for",
"a",
"Foo",
"field",
".",
"We",
"need",
"this",
"field",
"to",
"build",
"the",
"query",
"that",
... | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/FieldType.java#L1109-L1132 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/mapped/MappedQueryForFieldEq.java | MappedQueryForFieldEq.execute | public T execute(DatabaseConnection databaseConnection, ID id, ObjectCache objectCache) throws SQLException {
if (objectCache != null) {
T result = objectCache.get(clazz, id);
if (result != null) {
return result;
}
}
Object[] args = new Object[] { convertIdToFieldObject(id) };
// @SuppressWarnings("unchecked")
Object result = databaseConnection.queryForOne(statement, args, argFieldTypes, this, objectCache);
if (result == null) {
logger.debug("{} using '{}' and {} args, got no results", label, statement, args.length);
} else if (result == DatabaseConnection.MORE_THAN_ONE) {
logger.error("{} using '{}' and {} args, got >1 results", label, statement, args.length);
logArgs(args);
throw new SQLException(label + " got more than 1 result: " + statement);
} else {
logger.debug("{} using '{}' and {} args, got 1 result", label, statement, args.length);
}
logArgs(args);
@SuppressWarnings("unchecked")
T castResult = (T) result;
return castResult;
} | java | public T execute(DatabaseConnection databaseConnection, ID id, ObjectCache objectCache) throws SQLException {
if (objectCache != null) {
T result = objectCache.get(clazz, id);
if (result != null) {
return result;
}
}
Object[] args = new Object[] { convertIdToFieldObject(id) };
// @SuppressWarnings("unchecked")
Object result = databaseConnection.queryForOne(statement, args, argFieldTypes, this, objectCache);
if (result == null) {
logger.debug("{} using '{}' and {} args, got no results", label, statement, args.length);
} else if (result == DatabaseConnection.MORE_THAN_ONE) {
logger.error("{} using '{}' and {} args, got >1 results", label, statement, args.length);
logArgs(args);
throw new SQLException(label + " got more than 1 result: " + statement);
} else {
logger.debug("{} using '{}' and {} args, got 1 result", label, statement, args.length);
}
logArgs(args);
@SuppressWarnings("unchecked")
T castResult = (T) result;
return castResult;
} | [
"public",
"T",
"execute",
"(",
"DatabaseConnection",
"databaseConnection",
",",
"ID",
"id",
",",
"ObjectCache",
"objectCache",
")",
"throws",
"SQLException",
"{",
"if",
"(",
"objectCache",
"!=",
"null",
")",
"{",
"T",
"result",
"=",
"objectCache",
".",
"get",
... | Query for an object in the database which matches the id argument. | [
"Query",
"for",
"an",
"object",
"in",
"the",
"database",
"which",
"matches",
"the",
"id",
"argument",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/mapped/MappedQueryForFieldEq.java#L30-L53 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/db/BaseDatabaseType.java | BaseDatabaseType.appendStringType | protected void appendStringType(StringBuilder sb, FieldType fieldType, int fieldWidth) {
if (isVarcharFieldWidthSupported()) {
sb.append("VARCHAR(").append(fieldWidth).append(')');
} else {
sb.append("VARCHAR");
}
} | java | protected void appendStringType(StringBuilder sb, FieldType fieldType, int fieldWidth) {
if (isVarcharFieldWidthSupported()) {
sb.append("VARCHAR(").append(fieldWidth).append(')');
} else {
sb.append("VARCHAR");
}
} | [
"protected",
"void",
"appendStringType",
"(",
"StringBuilder",
"sb",
",",
"FieldType",
"fieldType",
",",
"int",
"fieldWidth",
")",
"{",
"if",
"(",
"isVarcharFieldWidthSupported",
"(",
")",
")",
"{",
"sb",
".",
"append",
"(",
"\"VARCHAR(\"",
")",
".",
"append",... | Output the SQL type for a Java String. | [
"Output",
"the",
"SQL",
"type",
"for",
"a",
"Java",
"String",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/db/BaseDatabaseType.java#L205-L211 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/db/BaseDatabaseType.java | BaseDatabaseType.appendDefaultValue | private void appendDefaultValue(StringBuilder sb, FieldType fieldType, Object defaultValue) {
if (fieldType.isEscapedDefaultValue()) {
appendEscapedWord(sb, defaultValue.toString());
} else {
sb.append(defaultValue);
}
} | java | private void appendDefaultValue(StringBuilder sb, FieldType fieldType, Object defaultValue) {
if (fieldType.isEscapedDefaultValue()) {
appendEscapedWord(sb, defaultValue.toString());
} else {
sb.append(defaultValue);
}
} | [
"private",
"void",
"appendDefaultValue",
"(",
"StringBuilder",
"sb",
",",
"FieldType",
"fieldType",
",",
"Object",
"defaultValue",
")",
"{",
"if",
"(",
"fieldType",
".",
"isEscapedDefaultValue",
"(",
")",
")",
"{",
"appendEscapedWord",
"(",
"sb",
",",
"defaultVa... | Output the SQL type for the default value for the type. | [
"Output",
"the",
"SQL",
"type",
"for",
"the",
"default",
"value",
"for",
"the",
"type",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/db/BaseDatabaseType.java#L315-L321 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/db/BaseDatabaseType.java | BaseDatabaseType.addSingleUnique | private void addSingleUnique(StringBuilder sb, FieldType fieldType, List<String> additionalArgs,
List<String> statementsAfter) {
StringBuilder alterSb = new StringBuilder();
alterSb.append(" UNIQUE (");
appendEscapedEntityName(alterSb, fieldType.getColumnName());
alterSb.append(')');
additionalArgs.add(alterSb.toString());
} | java | private void addSingleUnique(StringBuilder sb, FieldType fieldType, List<String> additionalArgs,
List<String> statementsAfter) {
StringBuilder alterSb = new StringBuilder();
alterSb.append(" UNIQUE (");
appendEscapedEntityName(alterSb, fieldType.getColumnName());
alterSb.append(')');
additionalArgs.add(alterSb.toString());
} | [
"private",
"void",
"addSingleUnique",
"(",
"StringBuilder",
"sb",
",",
"FieldType",
"fieldType",
",",
"List",
"<",
"String",
">",
"additionalArgs",
",",
"List",
"<",
"String",
">",
"statementsAfter",
")",
"{",
"StringBuilder",
"alterSb",
"=",
"new",
"StringBuild... | Add SQL to handle a unique=true field. THis is not for uniqueCombo=true. | [
"Add",
"SQL",
"to",
"handle",
"a",
"unique",
"=",
"true",
"field",
".",
"THis",
"is",
"not",
"for",
"uniqueCombo",
"=",
"true",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/db/BaseDatabaseType.java#L631-L638 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/DataPersisterManager.java | DataPersisterManager.registerDataPersisters | public static void registerDataPersisters(DataPersister... dataPersisters) {
// we build the map and replace it to lower the chance of concurrency issues
List<DataPersister> newList = new ArrayList<DataPersister>();
if (registeredPersisters != null) {
newList.addAll(registeredPersisters);
}
for (DataPersister persister : dataPersisters) {
newList.add(persister);
}
registeredPersisters = newList;
} | java | public static void registerDataPersisters(DataPersister... dataPersisters) {
// we build the map and replace it to lower the chance of concurrency issues
List<DataPersister> newList = new ArrayList<DataPersister>();
if (registeredPersisters != null) {
newList.addAll(registeredPersisters);
}
for (DataPersister persister : dataPersisters) {
newList.add(persister);
}
registeredPersisters = newList;
} | [
"public",
"static",
"void",
"registerDataPersisters",
"(",
"DataPersister",
"...",
"dataPersisters",
")",
"{",
"// we build the map and replace it to lower the chance of concurrency issues",
"List",
"<",
"DataPersister",
">",
"newList",
"=",
"new",
"ArrayList",
"<",
"DataPers... | Register a data type with the manager. | [
"Register",
"a",
"data",
"type",
"with",
"the",
"manager",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/DataPersisterManager.java#L51-L61 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/field/DataPersisterManager.java | DataPersisterManager.lookupForField | public static DataPersister lookupForField(Field field) {
// see if the any of the registered persisters are valid first
if (registeredPersisters != null) {
for (DataPersister persister : registeredPersisters) {
if (persister.isValidForField(field)) {
return persister;
}
// check the classes instead
for (Class<?> clazz : persister.getAssociatedClasses()) {
if (field.getType() == clazz) {
return persister;
}
}
}
}
// look it up in our built-in map by class
DataPersister dataPersister = builtInMap.get(field.getType().getName());
if (dataPersister != null) {
return dataPersister;
}
/*
* Special case for enum types. We can't put this in the registered persisters because we want people to be able
* to override it.
*/
if (field.getType().isEnum()) {
return DEFAULT_ENUM_PERSISTER;
} else {
/*
* Serializable classes return null here because we don't want them to be automatically configured for
* forwards compatibility with future field types that happen to be Serializable.
*/
return null;
}
} | java | public static DataPersister lookupForField(Field field) {
// see if the any of the registered persisters are valid first
if (registeredPersisters != null) {
for (DataPersister persister : registeredPersisters) {
if (persister.isValidForField(field)) {
return persister;
}
// check the classes instead
for (Class<?> clazz : persister.getAssociatedClasses()) {
if (field.getType() == clazz) {
return persister;
}
}
}
}
// look it up in our built-in map by class
DataPersister dataPersister = builtInMap.get(field.getType().getName());
if (dataPersister != null) {
return dataPersister;
}
/*
* Special case for enum types. We can't put this in the registered persisters because we want people to be able
* to override it.
*/
if (field.getType().isEnum()) {
return DEFAULT_ENUM_PERSISTER;
} else {
/*
* Serializable classes return null here because we don't want them to be automatically configured for
* forwards compatibility with future field types that happen to be Serializable.
*/
return null;
}
} | [
"public",
"static",
"DataPersister",
"lookupForField",
"(",
"Field",
"field",
")",
"{",
"// see if the any of the registered persisters are valid first",
"if",
"(",
"registeredPersisters",
"!=",
"null",
")",
"{",
"for",
"(",
"DataPersister",
"persister",
":",
"registeredP... | Lookup the data-type associated with the class.
@return The associated data-type interface or null if none found. | [
"Lookup",
"the",
"data",
"-",
"type",
"associated",
"with",
"the",
"class",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/field/DataPersisterManager.java#L75-L111 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/mapped/MappedUpdate.java | MappedUpdate.update | public int update(DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException {
try {
// there is always and id field as an argument so just return 0 lines updated
if (argFieldTypes.length <= 1) {
return 0;
}
Object[] args = getFieldObjects(data);
Object newVersion = null;
if (versionFieldType != null) {
newVersion = versionFieldType.extractJavaFieldValue(data);
newVersion = versionFieldType.moveToNextValue(newVersion);
args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(newVersion);
}
int rowC = databaseConnection.update(statement, args, argFieldTypes);
if (rowC > 0) {
if (newVersion != null) {
// if we have updated a row then update the version field in our object to the new value
versionFieldType.assignField(connectionSource, data, newVersion, false, null);
}
if (objectCache != null) {
// if we've changed something then see if we need to update our cache
Object id = idField.extractJavaFieldValue(data);
T cachedData = objectCache.get(clazz, id);
if (cachedData != null && cachedData != data) {
// copy each field from the updated data into the cached object
for (FieldType fieldType : tableInfo.getFieldTypes()) {
if (fieldType != idField) {
fieldType.assignField(connectionSource, cachedData,
fieldType.extractJavaFieldValue(data), false, objectCache);
}
}
}
}
}
logger.debug("update data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC);
if (args.length > 0) {
// need to do the (Object) cast to force args to be a single object
logger.trace("update arguments: {}", (Object) args);
}
return rowC;
} catch (SQLException e) {
throw SqlExceptionUtil.create("Unable to run update stmt on object " + data + ": " + statement, e);
}
} | java | public int update(DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException {
try {
// there is always and id field as an argument so just return 0 lines updated
if (argFieldTypes.length <= 1) {
return 0;
}
Object[] args = getFieldObjects(data);
Object newVersion = null;
if (versionFieldType != null) {
newVersion = versionFieldType.extractJavaFieldValue(data);
newVersion = versionFieldType.moveToNextValue(newVersion);
args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(newVersion);
}
int rowC = databaseConnection.update(statement, args, argFieldTypes);
if (rowC > 0) {
if (newVersion != null) {
// if we have updated a row then update the version field in our object to the new value
versionFieldType.assignField(connectionSource, data, newVersion, false, null);
}
if (objectCache != null) {
// if we've changed something then see if we need to update our cache
Object id = idField.extractJavaFieldValue(data);
T cachedData = objectCache.get(clazz, id);
if (cachedData != null && cachedData != data) {
// copy each field from the updated data into the cached object
for (FieldType fieldType : tableInfo.getFieldTypes()) {
if (fieldType != idField) {
fieldType.assignField(connectionSource, cachedData,
fieldType.extractJavaFieldValue(data), false, objectCache);
}
}
}
}
}
logger.debug("update data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC);
if (args.length > 0) {
// need to do the (Object) cast to force args to be a single object
logger.trace("update arguments: {}", (Object) args);
}
return rowC;
} catch (SQLException e) {
throw SqlExceptionUtil.create("Unable to run update stmt on object " + data + ": " + statement, e);
}
} | [
"public",
"int",
"update",
"(",
"DatabaseConnection",
"databaseConnection",
",",
"T",
"data",
",",
"ObjectCache",
"objectCache",
")",
"throws",
"SQLException",
"{",
"try",
"{",
"// there is always and id field as an argument so just return 0 lines updated",
"if",
"(",
"argF... | Update the object in the database. | [
"Update",
"the",
"object",
"in",
"the",
"database",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/mapped/MappedUpdate.java#L91-L134 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/mapped/BaseMappedStatement.java | BaseMappedStatement.getFieldObjects | protected Object[] getFieldObjects(Object data) throws SQLException {
Object[] objects = new Object[argFieldTypes.length];
for (int i = 0; i < argFieldTypes.length; i++) {
FieldType fieldType = argFieldTypes[i];
if (fieldType.isAllowGeneratedIdInsert()) {
objects[i] = fieldType.getFieldValueIfNotDefault(data);
} else {
objects[i] = fieldType.extractJavaFieldToSqlArgValue(data);
}
if (objects[i] == null) {
// NOTE: the default value could be null as well
objects[i] = fieldType.getDefaultValue();
}
}
return objects;
} | java | protected Object[] getFieldObjects(Object data) throws SQLException {
Object[] objects = new Object[argFieldTypes.length];
for (int i = 0; i < argFieldTypes.length; i++) {
FieldType fieldType = argFieldTypes[i];
if (fieldType.isAllowGeneratedIdInsert()) {
objects[i] = fieldType.getFieldValueIfNotDefault(data);
} else {
objects[i] = fieldType.extractJavaFieldToSqlArgValue(data);
}
if (objects[i] == null) {
// NOTE: the default value could be null as well
objects[i] = fieldType.getDefaultValue();
}
}
return objects;
} | [
"protected",
"Object",
"[",
"]",
"getFieldObjects",
"(",
"Object",
"data",
")",
"throws",
"SQLException",
"{",
"Object",
"[",
"]",
"objects",
"=",
"new",
"Object",
"[",
"argFieldTypes",
".",
"length",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i... | Return the array of field objects pulled from the data object. | [
"Return",
"the",
"array",
"of",
"field",
"objects",
"pulled",
"from",
"the",
"data",
"object",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/mapped/BaseMappedStatement.java#L45-L60 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/stmt/mapped/MappedPreparedStmt.java | MappedPreparedStmt.assignStatementArguments | private CompiledStatement assignStatementArguments(CompiledStatement stmt) throws SQLException {
boolean ok = false;
try {
if (limit != null) {
// we use this if SQL statement LIMITs are not supported by this database type
stmt.setMaxRows(limit.intValue());
}
// set any arguments if we are logging our object
Object[] argValues = null;
if (logger.isLevelEnabled(Level.TRACE) && argHolders.length > 0) {
argValues = new Object[argHolders.length];
}
for (int i = 0; i < argHolders.length; i++) {
Object argValue = argHolders[i].getSqlArgValue();
FieldType fieldType = argFieldTypes[i];
SqlType sqlType;
if (fieldType == null) {
sqlType = argHolders[i].getSqlType();
} else {
sqlType = fieldType.getSqlType();
}
stmt.setObject(i, argValue, sqlType);
if (argValues != null) {
argValues[i] = argValue;
}
}
logger.debug("prepared statement '{}' with {} args", statement, argHolders.length);
if (argValues != null) {
// need to do the (Object) cast to force args to be a single object
logger.trace("prepared statement arguments: {}", (Object) argValues);
}
ok = true;
return stmt;
} finally {
if (!ok) {
IOUtils.closeThrowSqlException(stmt, "statement");
}
}
} | java | private CompiledStatement assignStatementArguments(CompiledStatement stmt) throws SQLException {
boolean ok = false;
try {
if (limit != null) {
// we use this if SQL statement LIMITs are not supported by this database type
stmt.setMaxRows(limit.intValue());
}
// set any arguments if we are logging our object
Object[] argValues = null;
if (logger.isLevelEnabled(Level.TRACE) && argHolders.length > 0) {
argValues = new Object[argHolders.length];
}
for (int i = 0; i < argHolders.length; i++) {
Object argValue = argHolders[i].getSqlArgValue();
FieldType fieldType = argFieldTypes[i];
SqlType sqlType;
if (fieldType == null) {
sqlType = argHolders[i].getSqlType();
} else {
sqlType = fieldType.getSqlType();
}
stmt.setObject(i, argValue, sqlType);
if (argValues != null) {
argValues[i] = argValue;
}
}
logger.debug("prepared statement '{}' with {} args", statement, argHolders.length);
if (argValues != null) {
// need to do the (Object) cast to force args to be a single object
logger.trace("prepared statement arguments: {}", (Object) argValues);
}
ok = true;
return stmt;
} finally {
if (!ok) {
IOUtils.closeThrowSqlException(stmt, "statement");
}
}
} | [
"private",
"CompiledStatement",
"assignStatementArguments",
"(",
"CompiledStatement",
"stmt",
")",
"throws",
"SQLException",
"{",
"boolean",
"ok",
"=",
"false",
";",
"try",
"{",
"if",
"(",
"limit",
"!=",
"null",
")",
"{",
"// we use this if SQL statement LIMITs are no... | Assign arguments to the statement.
@return The statement passed in or null if it had to be closed on error. | [
"Assign",
"arguments",
"to",
"the",
"statement",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/stmt/mapped/MappedPreparedStmt.java#L89-L127 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/support/BaseConnectionSource.java | BaseConnectionSource.getSavedConnection | protected DatabaseConnection getSavedConnection() {
NestedConnection nested = specialConnection.get();
if (nested == null) {
return null;
} else {
return nested.connection;
}
} | java | protected DatabaseConnection getSavedConnection() {
NestedConnection nested = specialConnection.get();
if (nested == null) {
return null;
} else {
return nested.connection;
}
} | [
"protected",
"DatabaseConnection",
"getSavedConnection",
"(",
")",
"{",
"NestedConnection",
"nested",
"=",
"specialConnection",
".",
"get",
"(",
")",
";",
"if",
"(",
"nested",
"==",
"null",
")",
"{",
"return",
"null",
";",
"}",
"else",
"{",
"return",
"nested... | Returns the connection that has been saved or null if none. | [
"Returns",
"the",
"connection",
"that",
"has",
"been",
"saved",
"or",
"null",
"if",
"none",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/support/BaseConnectionSource.java#L29-L36 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/support/BaseConnectionSource.java | BaseConnectionSource.isSavedConnection | protected boolean isSavedConnection(DatabaseConnection connection) {
NestedConnection currentSaved = specialConnection.get();
if (currentSaved == null) {
return false;
} else if (currentSaved.connection == connection) {
// ignore the release when we have a saved connection
return true;
} else {
return false;
}
} | java | protected boolean isSavedConnection(DatabaseConnection connection) {
NestedConnection currentSaved = specialConnection.get();
if (currentSaved == null) {
return false;
} else if (currentSaved.connection == connection) {
// ignore the release when we have a saved connection
return true;
} else {
return false;
}
} | [
"protected",
"boolean",
"isSavedConnection",
"(",
"DatabaseConnection",
"connection",
")",
"{",
"NestedConnection",
"currentSaved",
"=",
"specialConnection",
".",
"get",
"(",
")",
";",
"if",
"(",
"currentSaved",
"==",
"null",
")",
"{",
"return",
"false",
";",
"}... | Return true if the connection being released is the one that has been saved. | [
"Return",
"true",
"if",
"the",
"connection",
"being",
"released",
"is",
"the",
"one",
"that",
"has",
"been",
"saved",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/support/BaseConnectionSource.java#L41-L51 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/support/BaseConnectionSource.java | BaseConnectionSource.clearSpecial | protected boolean clearSpecial(DatabaseConnection connection, Logger logger) {
NestedConnection currentSaved = specialConnection.get();
boolean cleared = false;
if (connection == null) {
// ignored
} else if (currentSaved == null) {
logger.error("no connection has been saved when clear() called");
} else if (currentSaved.connection == connection) {
if (currentSaved.decrementAndGet() == 0) {
// we only clear the connection if nested counter is 0
specialConnection.set(null);
}
cleared = true;
} else {
logger.error("connection saved {} is not the one being cleared {}", currentSaved.connection, connection);
}
// release should then be called after clear
return cleared;
} | java | protected boolean clearSpecial(DatabaseConnection connection, Logger logger) {
NestedConnection currentSaved = specialConnection.get();
boolean cleared = false;
if (connection == null) {
// ignored
} else if (currentSaved == null) {
logger.error("no connection has been saved when clear() called");
} else if (currentSaved.connection == connection) {
if (currentSaved.decrementAndGet() == 0) {
// we only clear the connection if nested counter is 0
specialConnection.set(null);
}
cleared = true;
} else {
logger.error("connection saved {} is not the one being cleared {}", currentSaved.connection, connection);
}
// release should then be called after clear
return cleared;
} | [
"protected",
"boolean",
"clearSpecial",
"(",
"DatabaseConnection",
"connection",
",",
"Logger",
"logger",
")",
"{",
"NestedConnection",
"currentSaved",
"=",
"specialConnection",
".",
"get",
"(",
")",
";",
"boolean",
"cleared",
"=",
"false",
";",
"if",
"(",
"conn... | Clear the connection that was previously saved.
@return True if the connection argument had been saved. | [
"Clear",
"the",
"connection",
"that",
"was",
"previously",
"saved",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/support/BaseConnectionSource.java#L80-L98 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/support/BaseConnectionSource.java | BaseConnectionSource.isSingleConnection | protected boolean isSingleConnection(DatabaseConnection conn1, DatabaseConnection conn2) throws SQLException {
// initialize the connections auto-commit flags
conn1.setAutoCommit(true);
conn2.setAutoCommit(true);
try {
// change conn1's auto-commit to be false
conn1.setAutoCommit(false);
if (conn2.isAutoCommit()) {
// if the 2nd connection's auto-commit is still true then we have multiple connections
return false;
} else {
// if the 2nd connection's auto-commit is also false then we have a single connection
return true;
}
} finally {
// restore its auto-commit
conn1.setAutoCommit(true);
}
} | java | protected boolean isSingleConnection(DatabaseConnection conn1, DatabaseConnection conn2) throws SQLException {
// initialize the connections auto-commit flags
conn1.setAutoCommit(true);
conn2.setAutoCommit(true);
try {
// change conn1's auto-commit to be false
conn1.setAutoCommit(false);
if (conn2.isAutoCommit()) {
// if the 2nd connection's auto-commit is still true then we have multiple connections
return false;
} else {
// if the 2nd connection's auto-commit is also false then we have a single connection
return true;
}
} finally {
// restore its auto-commit
conn1.setAutoCommit(true);
}
} | [
"protected",
"boolean",
"isSingleConnection",
"(",
"DatabaseConnection",
"conn1",
",",
"DatabaseConnection",
"conn2",
")",
"throws",
"SQLException",
"{",
"// initialize the connections auto-commit flags",
"conn1",
".",
"setAutoCommit",
"(",
"true",
")",
";",
"conn2",
".",... | Return true if the two connections seem to one one connection under the covers. | [
"Return",
"true",
"if",
"the",
"two",
"connections",
"seem",
"to",
"one",
"one",
"connection",
"under",
"the",
"covers",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/support/BaseConnectionSource.java#L103-L121 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/DatabaseTableConfigLoader.java | DatabaseTableConfigLoader.loadDatabaseConfigFromReader | public static List<DatabaseTableConfig<?>> loadDatabaseConfigFromReader(BufferedReader reader) throws SQLException {
List<DatabaseTableConfig<?>> list = new ArrayList<DatabaseTableConfig<?>>();
while (true) {
DatabaseTableConfig<?> config = DatabaseTableConfigLoader.fromReader(reader);
if (config == null) {
break;
}
list.add(config);
}
return list;
} | java | public static List<DatabaseTableConfig<?>> loadDatabaseConfigFromReader(BufferedReader reader) throws SQLException {
List<DatabaseTableConfig<?>> list = new ArrayList<DatabaseTableConfig<?>>();
while (true) {
DatabaseTableConfig<?> config = DatabaseTableConfigLoader.fromReader(reader);
if (config == null) {
break;
}
list.add(config);
}
return list;
} | [
"public",
"static",
"List",
"<",
"DatabaseTableConfig",
"<",
"?",
">",
">",
"loadDatabaseConfigFromReader",
"(",
"BufferedReader",
"reader",
")",
"throws",
"SQLException",
"{",
"List",
"<",
"DatabaseTableConfig",
"<",
"?",
">",
">",
"list",
"=",
"new",
"ArrayLis... | Load in a number of database configuration entries from a buffered reader. | [
"Load",
"in",
"a",
"number",
"of",
"database",
"configuration",
"entries",
"from",
"a",
"buffered",
"reader",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/DatabaseTableConfigLoader.java#L29-L39 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/DatabaseTableConfigLoader.java | DatabaseTableConfigLoader.fromReader | public static <T> DatabaseTableConfig<T> fromReader(BufferedReader reader) throws SQLException {
DatabaseTableConfig<T> config = new DatabaseTableConfig<T>();
boolean anything = false;
while (true) {
String line;
try {
line = reader.readLine();
} catch (IOException e) {
throw SqlExceptionUtil.create("Could not read DatabaseTableConfig from stream", e);
}
if (line == null) {
break;
}
// we do this so we can support multiple class configs per file
if (line.equals(CONFIG_FILE_END_MARKER)) {
break;
}
// we do this so we can support multiple class configs per file
if (line.equals(CONFIG_FILE_FIELDS_START)) {
readFields(reader, config);
continue;
}
// skip empty lines or comments
if (line.length() == 0 || line.startsWith("#") || line.equals(CONFIG_FILE_START_MARKER)) {
continue;
}
String[] parts = line.split("=", -2);
if (parts.length != 2) {
throw new SQLException("DatabaseTableConfig reading from stream cannot parse line: " + line);
}
readTableField(config, parts[0], parts[1]);
anything = true;
}
// if we got any config lines then we return the config
if (anything) {
return config;
} else {
// otherwise we return null for none
return null;
}
} | java | public static <T> DatabaseTableConfig<T> fromReader(BufferedReader reader) throws SQLException {
DatabaseTableConfig<T> config = new DatabaseTableConfig<T>();
boolean anything = false;
while (true) {
String line;
try {
line = reader.readLine();
} catch (IOException e) {
throw SqlExceptionUtil.create("Could not read DatabaseTableConfig from stream", e);
}
if (line == null) {
break;
}
// we do this so we can support multiple class configs per file
if (line.equals(CONFIG_FILE_END_MARKER)) {
break;
}
// we do this so we can support multiple class configs per file
if (line.equals(CONFIG_FILE_FIELDS_START)) {
readFields(reader, config);
continue;
}
// skip empty lines or comments
if (line.length() == 0 || line.startsWith("#") || line.equals(CONFIG_FILE_START_MARKER)) {
continue;
}
String[] parts = line.split("=", -2);
if (parts.length != 2) {
throw new SQLException("DatabaseTableConfig reading from stream cannot parse line: " + line);
}
readTableField(config, parts[0], parts[1]);
anything = true;
}
// if we got any config lines then we return the config
if (anything) {
return config;
} else {
// otherwise we return null for none
return null;
}
} | [
"public",
"static",
"<",
"T",
">",
"DatabaseTableConfig",
"<",
"T",
">",
"fromReader",
"(",
"BufferedReader",
"reader",
")",
"throws",
"SQLException",
"{",
"DatabaseTableConfig",
"<",
"T",
">",
"config",
"=",
"new",
"DatabaseTableConfig",
"<",
"T",
">",
"(",
... | Load a table configuration in from a text-file reader.
@return A config if any of the fields were set otherwise null if we reach EOF. | [
"Load",
"a",
"table",
"configuration",
"in",
"from",
"a",
"text",
"-",
"file",
"reader",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/DatabaseTableConfigLoader.java#L46-L86 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/DatabaseTableConfigLoader.java | DatabaseTableConfigLoader.write | public static <T> void write(BufferedWriter writer, DatabaseTableConfig<T> config) throws SQLException {
try {
writeConfig(writer, config);
} catch (IOException e) {
throw SqlExceptionUtil.create("Could not write config to writer", e);
}
} | java | public static <T> void write(BufferedWriter writer, DatabaseTableConfig<T> config) throws SQLException {
try {
writeConfig(writer, config);
} catch (IOException e) {
throw SqlExceptionUtil.create("Could not write config to writer", e);
}
} | [
"public",
"static",
"<",
"T",
">",
"void",
"write",
"(",
"BufferedWriter",
"writer",
",",
"DatabaseTableConfig",
"<",
"T",
">",
"config",
")",
"throws",
"SQLException",
"{",
"try",
"{",
"writeConfig",
"(",
"writer",
",",
"config",
")",
";",
"}",
"catch",
... | Write the table configuration to a buffered writer. | [
"Write",
"the",
"table",
"configuration",
"to",
"a",
"buffered",
"writer",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/DatabaseTableConfigLoader.java#L91-L97 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/DatabaseTableConfigLoader.java | DatabaseTableConfigLoader.writeConfig | private static <T> void writeConfig(BufferedWriter writer, DatabaseTableConfig<T> config) throws IOException,
SQLException {
writer.append(CONFIG_FILE_START_MARKER);
writer.newLine();
if (config.getDataClass() != null) {
writer.append(FIELD_NAME_DATA_CLASS).append('=').append(config.getDataClass().getName());
writer.newLine();
}
if (config.getTableName() != null) {
writer.append(FIELD_NAME_TABLE_NAME).append('=').append(config.getTableName());
writer.newLine();
}
writer.append(CONFIG_FILE_FIELDS_START);
writer.newLine();
if (config.getFieldConfigs() != null) {
for (DatabaseFieldConfig field : config.getFieldConfigs()) {
DatabaseFieldConfigLoader.write(writer, field, config.getTableName());
}
}
writer.append(CONFIG_FILE_FIELDS_END);
writer.newLine();
writer.append(CONFIG_FILE_END_MARKER);
writer.newLine();
} | java | private static <T> void writeConfig(BufferedWriter writer, DatabaseTableConfig<T> config) throws IOException,
SQLException {
writer.append(CONFIG_FILE_START_MARKER);
writer.newLine();
if (config.getDataClass() != null) {
writer.append(FIELD_NAME_DATA_CLASS).append('=').append(config.getDataClass().getName());
writer.newLine();
}
if (config.getTableName() != null) {
writer.append(FIELD_NAME_TABLE_NAME).append('=').append(config.getTableName());
writer.newLine();
}
writer.append(CONFIG_FILE_FIELDS_START);
writer.newLine();
if (config.getFieldConfigs() != null) {
for (DatabaseFieldConfig field : config.getFieldConfigs()) {
DatabaseFieldConfigLoader.write(writer, field, config.getTableName());
}
}
writer.append(CONFIG_FILE_FIELDS_END);
writer.newLine();
writer.append(CONFIG_FILE_END_MARKER);
writer.newLine();
} | [
"private",
"static",
"<",
"T",
">",
"void",
"writeConfig",
"(",
"BufferedWriter",
"writer",
",",
"DatabaseTableConfig",
"<",
"T",
">",
"config",
")",
"throws",
"IOException",
",",
"SQLException",
"{",
"writer",
".",
"append",
"(",
"CONFIG_FILE_START_MARKER",
")"... | Write the config to the writer. | [
"Write",
"the",
"config",
"to",
"the",
"writer",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/DatabaseTableConfigLoader.java#L106-L129 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/DatabaseTableConfigLoader.java | DatabaseTableConfigLoader.readTableField | private static <T> void readTableField(DatabaseTableConfig<T> config, String field, String value) {
if (field.equals(FIELD_NAME_DATA_CLASS)) {
try {
@SuppressWarnings("unchecked")
Class<T> clazz = (Class<T>) Class.forName(value);
config.setDataClass(clazz);
} catch (ClassNotFoundException e) {
throw new IllegalArgumentException("Unknown class specified for dataClass: " + value);
}
} else if (field.equals(FIELD_NAME_TABLE_NAME)) {
config.setTableName(value);
}
} | java | private static <T> void readTableField(DatabaseTableConfig<T> config, String field, String value) {
if (field.equals(FIELD_NAME_DATA_CLASS)) {
try {
@SuppressWarnings("unchecked")
Class<T> clazz = (Class<T>) Class.forName(value);
config.setDataClass(clazz);
} catch (ClassNotFoundException e) {
throw new IllegalArgumentException("Unknown class specified for dataClass: " + value);
}
} else if (field.equals(FIELD_NAME_TABLE_NAME)) {
config.setTableName(value);
}
} | [
"private",
"static",
"<",
"T",
">",
"void",
"readTableField",
"(",
"DatabaseTableConfig",
"<",
"T",
">",
"config",
",",
"String",
"field",
",",
"String",
"value",
")",
"{",
"if",
"(",
"field",
".",
"equals",
"(",
"FIELD_NAME_DATA_CLASS",
")",
")",
"{",
"... | Read a field into our table configuration for field=value line. | [
"Read",
"a",
"field",
"into",
"our",
"table",
"configuration",
"for",
"field",
"=",
"value",
"line",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/DatabaseTableConfigLoader.java#L134-L146 | train |
j256/ormlite-core | src/main/java/com/j256/ormlite/table/DatabaseTableConfigLoader.java | DatabaseTableConfigLoader.readFields | private static <T> void readFields(BufferedReader reader, DatabaseTableConfig<T> config) throws SQLException {
List<DatabaseFieldConfig> fields = new ArrayList<DatabaseFieldConfig>();
while (true) {
String line;
try {
line = reader.readLine();
} catch (IOException e) {
throw SqlExceptionUtil.create("Could not read next field from config file", e);
}
if (line == null || line.equals(CONFIG_FILE_FIELDS_END)) {
break;
}
DatabaseFieldConfig fieldConfig = DatabaseFieldConfigLoader.fromReader(reader);
if (fieldConfig == null) {
break;
}
fields.add(fieldConfig);
}
config.setFieldConfigs(fields);
} | java | private static <T> void readFields(BufferedReader reader, DatabaseTableConfig<T> config) throws SQLException {
List<DatabaseFieldConfig> fields = new ArrayList<DatabaseFieldConfig>();
while (true) {
String line;
try {
line = reader.readLine();
} catch (IOException e) {
throw SqlExceptionUtil.create("Could not read next field from config file", e);
}
if (line == null || line.equals(CONFIG_FILE_FIELDS_END)) {
break;
}
DatabaseFieldConfig fieldConfig = DatabaseFieldConfigLoader.fromReader(reader);
if (fieldConfig == null) {
break;
}
fields.add(fieldConfig);
}
config.setFieldConfigs(fields);
} | [
"private",
"static",
"<",
"T",
">",
"void",
"readFields",
"(",
"BufferedReader",
"reader",
",",
"DatabaseTableConfig",
"<",
"T",
">",
"config",
")",
"throws",
"SQLException",
"{",
"List",
"<",
"DatabaseFieldConfig",
">",
"fields",
"=",
"new",
"ArrayList",
"<",... | Read all of the fields information from the configuration file. | [
"Read",
"all",
"of",
"the",
"fields",
"information",
"from",
"the",
"configuration",
"file",
"."
] | 154d85bbb9614a0ea65a012251257831fb4fba21 | https://github.com/j256/ormlite-core/blob/154d85bbb9614a0ea65a012251257831fb4fba21/src/main/java/com/j256/ormlite/table/DatabaseTableConfigLoader.java#L151-L170 | train |
HubSpot/jackson-datatype-protobuf | src/main/java/com/hubspot/jackson/datatype/protobuf/ProtobufDeserializer.java | ProtobufDeserializer.readKey | private Object readKey(
FieldDescriptor field,
JsonParser parser,
DeserializationContext context
) throws IOException {
if (parser.getCurrentToken() != JsonToken.FIELD_NAME) {
throw reportWrongToken(JsonToken.FIELD_NAME, context, "Expected FIELD_NAME token");
}
String fieldName = parser.getCurrentName();
switch (field.getJavaType()) {
case INT:
// lifted from StdDeserializer since there's no method to call
try {
return NumberInput.parseInt(fieldName.trim());
} catch (IllegalArgumentException iae) {
Number number = (Number) context.handleWeirdStringValue(
_valueClass,
fieldName.trim(),
"not a valid int value"
);
return number == null ? 0 : number.intValue();
}
case LONG:
// lifted from StdDeserializer since there's no method to call
try {
return NumberInput.parseLong(fieldName.trim());
} catch (IllegalArgumentException iae) {
Number number = (Number) context.handleWeirdStringValue(
_valueClass,
fieldName.trim(),
"not a valid long value"
);
return number == null ? 0L : number.longValue();
}
case BOOLEAN:
// lifted from StdDeserializer since there's no method to call
String text = fieldName.trim();
if ("true".equals(text) || "True".equals(text)) {
return true;
}
if ("false".equals(text) || "False".equals(text)) {
return false;
}
Boolean b = (Boolean) context.handleWeirdStringValue(
_valueClass,
text,
"only \"true\" or \"false\" recognized"
);
return Boolean.TRUE.equals(b);
case STRING:
return fieldName;
case ENUM:
EnumValueDescriptor enumValueDescriptor = field.getEnumType().findValueByName(parser.getText());
if (enumValueDescriptor == null && !ignorableEnum(parser.getText().trim(), context)) {
throw context.weirdStringException(parser.getText(), field.getEnumType().getClass(),
"value not one of declared Enum instance names");
}
return enumValueDescriptor;
default:
throw new IllegalArgumentException("Unexpected map key type: " + field.getJavaType());
}
} | java | private Object readKey(
FieldDescriptor field,
JsonParser parser,
DeserializationContext context
) throws IOException {
if (parser.getCurrentToken() != JsonToken.FIELD_NAME) {
throw reportWrongToken(JsonToken.FIELD_NAME, context, "Expected FIELD_NAME token");
}
String fieldName = parser.getCurrentName();
switch (field.getJavaType()) {
case INT:
// lifted from StdDeserializer since there's no method to call
try {
return NumberInput.parseInt(fieldName.trim());
} catch (IllegalArgumentException iae) {
Number number = (Number) context.handleWeirdStringValue(
_valueClass,
fieldName.trim(),
"not a valid int value"
);
return number == null ? 0 : number.intValue();
}
case LONG:
// lifted from StdDeserializer since there's no method to call
try {
return NumberInput.parseLong(fieldName.trim());
} catch (IllegalArgumentException iae) {
Number number = (Number) context.handleWeirdStringValue(
_valueClass,
fieldName.trim(),
"not a valid long value"
);
return number == null ? 0L : number.longValue();
}
case BOOLEAN:
// lifted from StdDeserializer since there's no method to call
String text = fieldName.trim();
if ("true".equals(text) || "True".equals(text)) {
return true;
}
if ("false".equals(text) || "False".equals(text)) {
return false;
}
Boolean b = (Boolean) context.handleWeirdStringValue(
_valueClass,
text,
"only \"true\" or \"false\" recognized"
);
return Boolean.TRUE.equals(b);
case STRING:
return fieldName;
case ENUM:
EnumValueDescriptor enumValueDescriptor = field.getEnumType().findValueByName(parser.getText());
if (enumValueDescriptor == null && !ignorableEnum(parser.getText().trim(), context)) {
throw context.weirdStringException(parser.getText(), field.getEnumType().getClass(),
"value not one of declared Enum instance names");
}
return enumValueDescriptor;
default:
throw new IllegalArgumentException("Unexpected map key type: " + field.getJavaType());
}
} | [
"private",
"Object",
"readKey",
"(",
"FieldDescriptor",
"field",
",",
"JsonParser",
"parser",
",",
"DeserializationContext",
"context",
")",
"throws",
"IOException",
"{",
"if",
"(",
"parser",
".",
"getCurrentToken",
"(",
")",
"!=",
"JsonToken",
".",
"FIELD_NAME",
... | Specialized version of readValue just for reading map keys, because the StdDeserializer methods like
_parseIntPrimitive blow up when the current JsonToken is FIELD_NAME | [
"Specialized",
"version",
"of",
"readValue",
"just",
"for",
"reading",
"map",
"keys",
"because",
"the",
"StdDeserializer",
"methods",
"like",
"_parseIntPrimitive",
"blow",
"up",
"when",
"the",
"current",
"JsonToken",
"is",
"FIELD_NAME"
] | 33c6c8085421387d43770c6599fe1b9cb27ad10e | https://github.com/HubSpot/jackson-datatype-protobuf/blob/33c6c8085421387d43770c6599fe1b9cb27ad10e/src/main/java/com/hubspot/jackson/datatype/protobuf/ProtobufDeserializer.java#L132-L196 | train |
bujiio/buji-pac4j | src/main/java/io/buji/pac4j/util/ShiroHelper.java | ShiroHelper.populateSubject | public static void populateSubject(final LinkedHashMap<String, CommonProfile> profiles) {
if (profiles != null && profiles.size() > 0) {
final List<CommonProfile> listProfiles = ProfileHelper.flatIntoAProfileList(profiles);
try {
if (IS_FULLY_AUTHENTICATED_AUTHORIZER.isAuthorized(null, listProfiles)) {
SecurityUtils.getSubject().login(new Pac4jToken(listProfiles, false));
} else if (IS_REMEMBERED_AUTHORIZER.isAuthorized(null, listProfiles)) {
SecurityUtils.getSubject().login(new Pac4jToken(listProfiles, true));
}
} catch (final HttpAction e) {
throw new TechnicalException(e);
}
}
} | java | public static void populateSubject(final LinkedHashMap<String, CommonProfile> profiles) {
if (profiles != null && profiles.size() > 0) {
final List<CommonProfile> listProfiles = ProfileHelper.flatIntoAProfileList(profiles);
try {
if (IS_FULLY_AUTHENTICATED_AUTHORIZER.isAuthorized(null, listProfiles)) {
SecurityUtils.getSubject().login(new Pac4jToken(listProfiles, false));
} else if (IS_REMEMBERED_AUTHORIZER.isAuthorized(null, listProfiles)) {
SecurityUtils.getSubject().login(new Pac4jToken(listProfiles, true));
}
} catch (final HttpAction e) {
throw new TechnicalException(e);
}
}
} | [
"public",
"static",
"void",
"populateSubject",
"(",
"final",
"LinkedHashMap",
"<",
"String",
",",
"CommonProfile",
">",
"profiles",
")",
"{",
"if",
"(",
"profiles",
"!=",
"null",
"&&",
"profiles",
".",
"size",
"(",
")",
">",
"0",
")",
"{",
"final",
"List... | Populate the authenticated user profiles in the Shiro subject.
@param profiles the linked hashmap of profiles | [
"Populate",
"the",
"authenticated",
"user",
"profiles",
"in",
"the",
"Shiro",
"subject",
"."
] | 5ce149161f359074df09bc47b9f2aed8e17141a2 | https://github.com/bujiio/buji-pac4j/blob/5ce149161f359074df09bc47b9f2aed8e17141a2/src/main/java/io/buji/pac4j/util/ShiroHelper.java#L51-L64 | train |
bujiio/buji-pac4j | src/main/java/io/buji/pac4j/subject/Pac4jPrincipal.java | Pac4jPrincipal.getName | @Override
public String getName() {
CommonProfile profile = this.getProfile();
if(null == principalNameAttribute) {
return profile.getId();
}
Object attrValue = profile.getAttribute(principalNameAttribute);
return (null == attrValue) ? null : String.valueOf(attrValue);
} | java | @Override
public String getName() {
CommonProfile profile = this.getProfile();
if(null == principalNameAttribute) {
return profile.getId();
}
Object attrValue = profile.getAttribute(principalNameAttribute);
return (null == attrValue) ? null : String.valueOf(attrValue);
} | [
"@",
"Override",
"public",
"String",
"getName",
"(",
")",
"{",
"CommonProfile",
"profile",
"=",
"this",
".",
"getProfile",
"(",
")",
";",
"if",
"(",
"null",
"==",
"principalNameAttribute",
")",
"{",
"return",
"profile",
".",
"getId",
"(",
")",
";",
"}",
... | Returns a name for the principal based upon one of the attributes
of the main CommonProfile. The attribute name used to query the CommonProfile
is specified in the constructor.
@return a name for the Principal or null if the attribute is not populated. | [
"Returns",
"a",
"name",
"for",
"the",
"principal",
"based",
"upon",
"one",
"of",
"the",
"attributes",
"of",
"the",
"main",
"CommonProfile",
".",
"The",
"attribute",
"name",
"used",
"to",
"query",
"the",
"CommonProfile",
"is",
"specified",
"in",
"the",
"const... | 5ce149161f359074df09bc47b9f2aed8e17141a2 | https://github.com/bujiio/buji-pac4j/blob/5ce149161f359074df09bc47b9f2aed8e17141a2/src/main/java/io/buji/pac4j/subject/Pac4jPrincipal.java#L107-L115 | train |
Talend/tesb-rt-se | examples/tesb/library-service/common/src/main/java/org/talend/services/demos/common/Utils.java | Utils.showBooks | public static void showBooks(final ListOfBooks booksList){
if(booksList != null && booksList.getBook() != null && !booksList.getBook().isEmpty()){
List<BookType> books = booksList.getBook();
System.out.println("\nNumber of books: " + books.size());
int cnt = 0;
for (BookType book : books) {
System.out.println("\nBookNum: " + (cnt++ + 1));
List<PersonType> authors = book.getAuthor();
if(authors != null && !authors.isEmpty()){
for (PersonType author : authors) {
System.out.println("Author: " + author.getFirstName() +
" " + author.getLastName());
}
}
System.out.println("Title: " + book.getTitle());
System.out.println("Year: " + book.getYearPublished());
if(book.getISBN()!=null){
System.out.println("ISBN: " + book.getISBN());
}
}
}else{
System.out.println("List of books is empty");
}
System.out.println("");
} | java | public static void showBooks(final ListOfBooks booksList){
if(booksList != null && booksList.getBook() != null && !booksList.getBook().isEmpty()){
List<BookType> books = booksList.getBook();
System.out.println("\nNumber of books: " + books.size());
int cnt = 0;
for (BookType book : books) {
System.out.println("\nBookNum: " + (cnt++ + 1));
List<PersonType> authors = book.getAuthor();
if(authors != null && !authors.isEmpty()){
for (PersonType author : authors) {
System.out.println("Author: " + author.getFirstName() +
" " + author.getLastName());
}
}
System.out.println("Title: " + book.getTitle());
System.out.println("Year: " + book.getYearPublished());
if(book.getISBN()!=null){
System.out.println("ISBN: " + book.getISBN());
}
}
}else{
System.out.println("List of books is empty");
}
System.out.println("");
} | [
"public",
"static",
"void",
"showBooks",
"(",
"final",
"ListOfBooks",
"booksList",
")",
"{",
"if",
"(",
"booksList",
"!=",
"null",
"&&",
"booksList",
".",
"getBook",
"(",
")",
"!=",
"null",
"&&",
"!",
"booksList",
".",
"getBook",
"(",
")",
".",
"isEmpty"... | Show books.
@param booksList the books list | [
"Show",
"books",
"."
] | 0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886 | https://github.com/Talend/tesb-rt-se/blob/0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886/examples/tesb/library-service/common/src/main/java/org/talend/services/demos/common/Utils.java#L19-L45 | train |
Talend/tesb-rt-se | examples/tesb/locator-service/soap-service/war/src/main/java/demo/service/ContextListener.java | ContextListener.contextInitialized | public void contextInitialized(ServletContextEvent event) {
this.context = event.getServletContext();
// Output a simple message to the server's console
System.out.println("The Simple Web App. Is Ready");
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
"/client.xml");
LocatorService client = (LocatorService) context
.getBean("locatorService");
String serviceHost = this.context.getInitParameter("serviceHost");
try {
client.registerEndpoint(new QName(
"http://talend.org/esb/examples/", "GreeterService"),
serviceHost, BindingType.SOAP_11, TransportType.HTTP, null);
} catch (InterruptedExceptionFault e) {
e.printStackTrace();
} catch (ServiceLocatorFault e) {
e.printStackTrace();
}
} | java | public void contextInitialized(ServletContextEvent event) {
this.context = event.getServletContext();
// Output a simple message to the server's console
System.out.println("The Simple Web App. Is Ready");
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
"/client.xml");
LocatorService client = (LocatorService) context
.getBean("locatorService");
String serviceHost = this.context.getInitParameter("serviceHost");
try {
client.registerEndpoint(new QName(
"http://talend.org/esb/examples/", "GreeterService"),
serviceHost, BindingType.SOAP_11, TransportType.HTTP, null);
} catch (InterruptedExceptionFault e) {
e.printStackTrace();
} catch (ServiceLocatorFault e) {
e.printStackTrace();
}
} | [
"public",
"void",
"contextInitialized",
"(",
"ServletContextEvent",
"event",
")",
"{",
"this",
".",
"context",
"=",
"event",
".",
"getServletContext",
"(",
")",
";",
"// Output a simple message to the server's console",
"System",
".",
"out",
".",
"println",
"(",
"\"... | is ready to service requests | [
"is",
"ready",
"to",
"service",
"requests"
] | 0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886 | https://github.com/Talend/tesb-rt-se/blob/0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886/examples/tesb/locator-service/soap-service/war/src/main/java/demo/service/ContextListener.java#L63-L85 | train |
Talend/tesb-rt-se | locator/src/main/java/org/talend/esb/servicelocator/cxf/internal/CXFEndpointProvider.java | CXFEndpointProvider.serializeEPR | private void serializeEPR(EndpointReferenceType wsAddr, Node parent) throws ServiceLocatorException {
try {
JAXBElement<EndpointReferenceType> ep =
WSA_OBJECT_FACTORY.createEndpointReference(wsAddr);
createMarshaller().marshal(ep, parent);
} catch (JAXBException e) {
if (LOG.isLoggable(Level.SEVERE)) {
LOG.log(Level.SEVERE,
"Failed to serialize endpoint data", e);
}
throw new ServiceLocatorException("Failed to serialize endpoint data", e);
}
} | java | private void serializeEPR(EndpointReferenceType wsAddr, Node parent) throws ServiceLocatorException {
try {
JAXBElement<EndpointReferenceType> ep =
WSA_OBJECT_FACTORY.createEndpointReference(wsAddr);
createMarshaller().marshal(ep, parent);
} catch (JAXBException e) {
if (LOG.isLoggable(Level.SEVERE)) {
LOG.log(Level.SEVERE,
"Failed to serialize endpoint data", e);
}
throw new ServiceLocatorException("Failed to serialize endpoint data", e);
}
} | [
"private",
"void",
"serializeEPR",
"(",
"EndpointReferenceType",
"wsAddr",
",",
"Node",
"parent",
")",
"throws",
"ServiceLocatorException",
"{",
"try",
"{",
"JAXBElement",
"<",
"EndpointReferenceType",
">",
"ep",
"=",
"WSA_OBJECT_FACTORY",
".",
"createEndpointReference"... | Inserts a marshalled endpoint reference to a given DOM tree rooted by parent.
@param wsAddr
@param parent
@throws ServiceLocatorException | [
"Inserts",
"a",
"marshalled",
"endpoint",
"reference",
"to",
"a",
"given",
"DOM",
"tree",
"rooted",
"by",
"parent",
"."
] | 0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886 | https://github.com/Talend/tesb-rt-se/blob/0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886/locator/src/main/java/org/talend/esb/servicelocator/cxf/internal/CXFEndpointProvider.java#L205-L217 | train |
Talend/tesb-rt-se | locator/src/main/java/org/talend/esb/servicelocator/cxf/internal/CXFEndpointProvider.java | CXFEndpointProvider.createEPR | private static EndpointReferenceType createEPR(String address, SLProperties props) {
EndpointReferenceType epr = WSAEndpointReferenceUtils.getEndpointReference(address);
if (props != null) {
addProperties(epr, props);
}
return epr;
} | java | private static EndpointReferenceType createEPR(String address, SLProperties props) {
EndpointReferenceType epr = WSAEndpointReferenceUtils.getEndpointReference(address);
if (props != null) {
addProperties(epr, props);
}
return epr;
} | [
"private",
"static",
"EndpointReferenceType",
"createEPR",
"(",
"String",
"address",
",",
"SLProperties",
"props",
")",
"{",
"EndpointReferenceType",
"epr",
"=",
"WSAEndpointReferenceUtils",
".",
"getEndpointReference",
"(",
"address",
")",
";",
"if",
"(",
"props",
... | Creates an endpoint reference from a given adress.
@param address
@param props
@return | [
"Creates",
"an",
"endpoint",
"reference",
"from",
"a",
"given",
"adress",
"."
] | 0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886 | https://github.com/Talend/tesb-rt-se/blob/0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886/locator/src/main/java/org/talend/esb/servicelocator/cxf/internal/CXFEndpointProvider.java#L279-L285 | train |
Talend/tesb-rt-se | locator/src/main/java/org/talend/esb/servicelocator/cxf/internal/CXFEndpointProvider.java | CXFEndpointProvider.createEPR | private static EndpointReferenceType createEPR(Server server, String address, SLProperties props) {
EndpointReferenceType sourceEPR = server.getEndpoint().getEndpointInfo().getTarget();
EndpointReferenceType targetEPR = WSAEndpointReferenceUtils.duplicate(sourceEPR);
WSAEndpointReferenceUtils.setAddress(targetEPR, address);
if (props != null) {
addProperties(targetEPR, props);
}
return targetEPR;
} | java | private static EndpointReferenceType createEPR(Server server, String address, SLProperties props) {
EndpointReferenceType sourceEPR = server.getEndpoint().getEndpointInfo().getTarget();
EndpointReferenceType targetEPR = WSAEndpointReferenceUtils.duplicate(sourceEPR);
WSAEndpointReferenceUtils.setAddress(targetEPR, address);
if (props != null) {
addProperties(targetEPR, props);
}
return targetEPR;
} | [
"private",
"static",
"EndpointReferenceType",
"createEPR",
"(",
"Server",
"server",
",",
"String",
"address",
",",
"SLProperties",
"props",
")",
"{",
"EndpointReferenceType",
"sourceEPR",
"=",
"server",
".",
"getEndpoint",
"(",
")",
".",
"getEndpointInfo",
"(",
")... | Creates an endpoint reference by duplicating the endpoint reference of a given server.
@param server
@param address
@param props
@return | [
"Creates",
"an",
"endpoint",
"reference",
"by",
"duplicating",
"the",
"endpoint",
"reference",
"of",
"a",
"given",
"server",
"."
] | 0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886 | https://github.com/Talend/tesb-rt-se/blob/0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886/locator/src/main/java/org/talend/esb/servicelocator/cxf/internal/CXFEndpointProvider.java#L294-L303 | train |
Talend/tesb-rt-se | locator/src/main/java/org/talend/esb/servicelocator/cxf/internal/CXFEndpointProvider.java | CXFEndpointProvider.addProperties | private static void addProperties(EndpointReferenceType epr, SLProperties props) {
MetadataType metadata = WSAEndpointReferenceUtils.getSetMetadata(epr);
ServiceLocatorPropertiesType jaxbProps = SLPropertiesConverter.toServiceLocatorPropertiesType(props);
JAXBElement<ServiceLocatorPropertiesType>
slp = SL_OBJECT_FACTORY.createServiceLocatorProperties(jaxbProps);
metadata.getAny().add(slp);
} | java | private static void addProperties(EndpointReferenceType epr, SLProperties props) {
MetadataType metadata = WSAEndpointReferenceUtils.getSetMetadata(epr);
ServiceLocatorPropertiesType jaxbProps = SLPropertiesConverter.toServiceLocatorPropertiesType(props);
JAXBElement<ServiceLocatorPropertiesType>
slp = SL_OBJECT_FACTORY.createServiceLocatorProperties(jaxbProps);
metadata.getAny().add(slp);
} | [
"private",
"static",
"void",
"addProperties",
"(",
"EndpointReferenceType",
"epr",
",",
"SLProperties",
"props",
")",
"{",
"MetadataType",
"metadata",
"=",
"WSAEndpointReferenceUtils",
".",
"getSetMetadata",
"(",
"epr",
")",
";",
"ServiceLocatorPropertiesType",
"jaxbPro... | Adds service locator properties to an endpoint reference.
@param epr
@param props | [
"Adds",
"service",
"locator",
"properties",
"to",
"an",
"endpoint",
"reference",
"."
] | 0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886 | https://github.com/Talend/tesb-rt-se/blob/0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886/locator/src/main/java/org/talend/esb/servicelocator/cxf/internal/CXFEndpointProvider.java#L310-L317 | train |
Talend/tesb-rt-se | locator/src/main/java/org/talend/esb/servicelocator/cxf/internal/CXFEndpointProvider.java | CXFEndpointProvider.getServiceName | private static QName getServiceName(Server server) {
QName serviceName;
String bindingId = getBindingId(server);
EndpointInfo eInfo = server.getEndpoint().getEndpointInfo();
if (JAXRS_BINDING_ID.equals(bindingId)) {
serviceName = eInfo.getName();
} else {
ServiceInfo serviceInfo = eInfo.getService();
serviceName = serviceInfo.getName();
}
return serviceName;
} | java | private static QName getServiceName(Server server) {
QName serviceName;
String bindingId = getBindingId(server);
EndpointInfo eInfo = server.getEndpoint().getEndpointInfo();
if (JAXRS_BINDING_ID.equals(bindingId)) {
serviceName = eInfo.getName();
} else {
ServiceInfo serviceInfo = eInfo.getService();
serviceName = serviceInfo.getName();
}
return serviceName;
} | [
"private",
"static",
"QName",
"getServiceName",
"(",
"Server",
"server",
")",
"{",
"QName",
"serviceName",
";",
"String",
"bindingId",
"=",
"getBindingId",
"(",
"server",
")",
";",
"EndpointInfo",
"eInfo",
"=",
"server",
".",
"getEndpoint",
"(",
")",
".",
"g... | Extracts the service name from a Server.
@param server
@return | [
"Extracts",
"the",
"service",
"name",
"from",
"a",
"Server",
"."
] | 0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886 | https://github.com/Talend/tesb-rt-se/blob/0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886/locator/src/main/java/org/talend/esb/servicelocator/cxf/internal/CXFEndpointProvider.java#L324-L336 | train |
Talend/tesb-rt-se | locator/src/main/java/org/talend/esb/servicelocator/cxf/internal/CXFEndpointProvider.java | CXFEndpointProvider.getBindingId | private static String getBindingId(Server server) {
Endpoint ep = server.getEndpoint();
BindingInfo bi = ep.getBinding().getBindingInfo();
return bi.getBindingId();
} | java | private static String getBindingId(Server server) {
Endpoint ep = server.getEndpoint();
BindingInfo bi = ep.getBinding().getBindingInfo();
return bi.getBindingId();
} | [
"private",
"static",
"String",
"getBindingId",
"(",
"Server",
"server",
")",
"{",
"Endpoint",
"ep",
"=",
"server",
".",
"getEndpoint",
"(",
")",
";",
"BindingInfo",
"bi",
"=",
"ep",
".",
"getBinding",
"(",
")",
".",
"getBindingInfo",
"(",
")",
";",
"retu... | Extracts the bindingId from a Server.
@param server
@return | [
"Extracts",
"the",
"bindingId",
"from",
"a",
"Server",
"."
] | 0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886 | https://github.com/Talend/tesb-rt-se/blob/0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886/locator/src/main/java/org/talend/esb/servicelocator/cxf/internal/CXFEndpointProvider.java#L343-L347 | train |
Talend/tesb-rt-se | locator/src/main/java/org/talend/esb/servicelocator/cxf/internal/CXFEndpointProvider.java | CXFEndpointProvider.map2BindingType | private static BindingType map2BindingType(String bindingId) {
BindingType type;
if (SOAP11_BINDING_ID.equals(bindingId)) {
type = BindingType.SOAP11;
} else if (SOAP12_BINDING_ID.equals(bindingId)) {
type = BindingType.SOAP12;
} else if (JAXRS_BINDING_ID.equals(bindingId)) {
type = BindingType.JAXRS;
} else {
type = BindingType.OTHER;
}
return type;
} | java | private static BindingType map2BindingType(String bindingId) {
BindingType type;
if (SOAP11_BINDING_ID.equals(bindingId)) {
type = BindingType.SOAP11;
} else if (SOAP12_BINDING_ID.equals(bindingId)) {
type = BindingType.SOAP12;
} else if (JAXRS_BINDING_ID.equals(bindingId)) {
type = BindingType.JAXRS;
} else {
type = BindingType.OTHER;
}
return type;
} | [
"private",
"static",
"BindingType",
"map2BindingType",
"(",
"String",
"bindingId",
")",
"{",
"BindingType",
"type",
";",
"if",
"(",
"SOAP11_BINDING_ID",
".",
"equals",
"(",
"bindingId",
")",
")",
"{",
"type",
"=",
"BindingType",
".",
"SOAP11",
";",
"}",
"els... | Maps a bindingId to its corresponding BindingType.
@param bindingId
@return | [
"Maps",
"a",
"bindingId",
"to",
"its",
"corresponding",
"BindingType",
"."
] | 0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886 | https://github.com/Talend/tesb-rt-se/blob/0a151a6d91ffff65ac4b5ee0c5b2c882ac28d886/locator/src/main/java/org/talend/esb/servicelocator/cxf/internal/CXFEndpointProvider.java#L363-L375 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.