public TypedExpression GetTypedExpression()
{
var itemType = PgTypesConverter.CreatePgValueTypeFromObjectType(typeof(TValue));
var arrayType = new KDPgValueTypeArray(itemType, typeof(TValue));
return(new TypedExpression(GetRawQuery(), arrayType));
}
public static WhereBuilder<TModel> Eq<T>(Expression<Func<TModel, T>> field, T value)
{
var column = NodeVisitor.EvaluateExpressionToColumn(field.Body);
var pgValue = PgTypesConverter.ConvertObjectToPgValue(value);
var right = TypedExpression.FromPgValue(pgValue);
return new WhereBuilder<TModel>(ExpressionBuilders.Eq(column.TypedExpression, right));
}
public static TypedExpression In(TypedExpression left, IEnumerable array)
{
RawQuery rq = new RawQuery();
rq.AppendSurround(left.RawQuery)
.Append(" = ANY(")
.Append(PgTypesConverter.ConvertObjectToPgValue(array))
.Append(")");
return(new TypedExpression(rq, KDPgValueTypeInstances.Boolean));
}
private string RenderSimple(RenderingContext ctx)
{
var sb = new StringBuilder();
ctx.AliasesStack.Push(_aliases);
foreach (var part in _parts)
{
if (part.Text != null)
{
sb.Append(part.Text);
}
if (part.Table != null)
{
var alias = ResolvePlaceholder(ctx, part.Table);
if (alias != null)
{
sb.Append(EscapeUtils.QuoteObjectName(alias));
}
else
{
sb.Append(EscapeUtils.QuoteTable(part.Table.Table.Name, part.Table.Table.Schema));
}
}
if (part.Column != null)
{
// if (!ctx.skipExplicitColumnTableNames) {
var alias = ResolvePlaceholder(ctx, part.Column.TablePlaceholder);
if (alias != null)
{
sb.Append(EscapeUtils.QuoteObjectName(alias));
sb.Append(".");
}
sb.Append(EscapeUtils.QuoteObjectName(part.Column.Column.Name));
}
else if (part.ParamIdx != -1)
{
sb.Append(PgTypesConverter.ConvertToPgString(_parameters[part.ParamIdx]));
}
else if (part.RawQuery != null)
{
sb.Append(part.RawQuery.RenderSimple(ctx));
}
}
ctx.AliasesStack.Pop();
return(sb.ToString());
}
public object ParseResult(object[] values)
{
var obj = Activator.CreateInstance(Table.ModelType);
for (var i = 0; i < _columns.Count; i++)
{
var col = _columns[i];
var val = PgTypesConverter.ConvertFromRawSqlValue(col.Type, values[i]);
col.PropertyInfo.SetValue(obj, val);
}
return(obj);
}
public UpdateStatementsBuilder <TModel> SetField <TValue>(Expression <Func <TModel, TValue> > field, TValue value)
{
var pi = NodeVisitor.VisitPath(field, null);
var npgValue = PgTypesConverter.ConvertToPgValue(pi.Expression.Type, value);
if (pi.JsonPath.Count > 0)
{
AddUpdate(pi.Column, src => ExpressionBuilders.JsonSet(src, pi.JsonPath, TypedExpression.FromPgValue(npgValue)));
}
else
{
AddUpdate(pi.Column, src => TypedExpression.FromPgValue(npgValue));
}
return(this);
}
public object ParseResult(object[] values)
{
object[] constructorParams = new object[Entries.Count];
int columnIdx = 0;
for (var i = 0; i < Entries.Count; i++)
{
var entry = Entries[i];
if (entry.MemberPgTable != null)
{
var table = entry.MemberPgTable;
var isNull = (bool)PgTypesConverter.ConvertFromRawSqlValue(KDPgValueTypeInstances.Boolean, values[columnIdx++]);
if (isNull)
{
constructorParams[i] = null;
columnIdx += table.Columns.Count;
}
else
{
var modelObj = Activator.CreateInstance(table.ModelType);
foreach (var column in table.Columns)
{
var val = PgTypesConverter.ConvertFromRawSqlValue(column.Type, values[columnIdx++]);
column.PropertyInfo.SetValue(modelObj, val);
}
constructorParams[i] = modelObj;
}
}
else if (entry.MemberPgType != null)
{
constructorParams[i] = PgTypesConverter.ConvertFromRawSqlValue(entry.MemberPgType, values[columnIdx++]);
}
else
{
throw new Exception();
}
}
return(Activator.CreateInstance(typeof(TModel), constructorParams));
}
public object ParseResult(object[] values)
{
var obj = Activator.CreateInstance(Table.ModelType);
var isNull = (bool)PgTypesConverter.ConvertFromRawSqlValue(KDPgValueTypeInstances.Boolean, values[0]);
if (isNull)
{
return(null);
}
for (var i = 0; i < _columns.Count; i++)
{
var col = _columns[i];
var val = PgTypesConverter.ConvertFromRawSqlValue(col.Type, values[1 + i]);
col.PropertyInfo.SetValue(obj, val);
}
return(obj);
}
public static bool TryInlineShortValue(PgValue pgValue, out string inlined)
{
inlined = null;
object value = pgValue.Value;
switch (pgValue.Type)
{
case KDPgValueTypeEnum _:
inlined = PgTypesConverter.ConvertToPgString(value);
return(true);
}
switch (value)
{
case string s when pgValue.Type == KDPgValueTypeInstances.String && s.Length < 30:
inlined = PgTypesConverter.ConvertToPgString(s);
return(true);
case int v:
inlined = PgTypesConverter.ConvertToPgString(v);
return(true);
case null:
inlined = "NULL";
return(true);
case true:
inlined = "TRUE";
return(true);
case false:
inlined = "FALSE";
return(true);
}
return(false);
}
public static TypedExpression ContainsAny(TypedExpression left, IEnumerable array) => ContainsAny(left, TypedExpression.FromPgValue(PgTypesConverter.ConvertObjectToPgValue(array)));
public object ParseResult(object[] values)
{
return(PgTypesConverter.ConvertFromRawSqlValue(_type, values[0]));
}
public RawQuery GetRawQuery()
{
if (IsEmpty)
{
return(RawQuery.Create("SELECT 0"));
}
RawQuery rq = new RawQuery();
var columns = _columns.Count == 0 ? AllColumnsWithoutAutoIncrement : _columns;
rq.Append("INSERT INTO ");
rq.AppendTableName(Table.Name, Table.Schema);
rq.Append("(");
rq.AppendColumnNames(columns.Select(x => x.columnDescriptor.Name));
if (_idColumn != null)
{
if (columns.Count > 0)
{
rq.Append(",");
}
rq.AppendColumnName(_idColumn.Name);
}
rq.Append(")");
rq.Append(" VALUES ");
var first = true;
foreach (var obj in _objects)
{
if (!first)
{
rq.Append(",");
}
rq.Append("(");
for (int i = 0; i < columns.Count; i++)
{
var column = columns[i];
if (i > 0)
{
rq.Append(",");
}
if (column.subquery == null)
{
object val = ModelsRegistry.GetModelValueByColumn(obj, column.columnDescriptor);
var npgValue = PgTypesConverter.ConvertToPgValue(column.columnDescriptor.Type, val);
rq.Append(npgValue);
}
else
{
rq.AppendSurround(column.subquery.GetRawQuery());
}
}
if (_idColumn != null)
{
if (columns.Count > 0)
{
rq.Append(",");
}
rq.Append(ExpressionBuilders.CurrSeqValueOfTable(_idRefColumn).RawQuery);
}
rq.Append(")");
first = false;
}
if (_onInsertConflict == OnInsertConflict.DoNothing)
{
rq.Append(" ON CONFLICT DO NOTHING ");
}
if (_onInsertConflict == OnInsertConflict.DoUpdate)
{
rq.Append(" ON CONFLICT (");
var fields = new FieldListBuilder <TModel>();
_onInsertConflictUpdateFields(fields);
first = true;
foreach (var column in fields.Fields)
{
if (!first)
{
rq.Append(", ");
}
rq.AppendColumnName(column.Name);
first = false;
}
rq.Append(") DO UPDATE SET ");
var updateStatementsBuilder = new UpdateStatementsBuilder <TModel>();
_onInsertConflictUpdate(updateStatementsBuilder);
first = true;
foreach (var(column, typedExpression) in updateStatementsBuilder.UpdateParts)
{
if (!first)
{
rq.Append(", ");
}
rq.AppendColumnName(column.Name)
.Append(" = ")
.Append(typedExpression.RawQuery);
first = false;
}
}
if (TableModel.PrimaryKey != null)
{
rq.Append(" RETURNING ");
rq.AppendColumnName(TableModel.PrimaryKey.Name);
}
rq.Append(";");
if (_outputVariable != null)
{
rq.Append(" SELECT ");
rq.Append(ExpressionBuilders.SetConfigText(_outputVariable, ExpressionBuilders.LastVal(), true).RawQuery);
}
rq.SkipExplicitColumnTableNames();
return(rq);
}
public static TypedExpression Cast(TypedExpression value, Type type) => Cast(value, PgTypesConverter.CreatePgValueTypeFromObjectType(type));
public static TypedExpression KDPgJsonbRemoveByValue <T>(TypedExpression array, IEnumerable <object> jsonPath, T item, bool firstOnly)
{
var pgValue = PgTypesConverter.ConvertObjectToPgValue(item);
return(KDPgJsonbRemoveByValue(array, jsonPath, TypedExpression.FromPgValue(pgValue), firstOnly));
}
public static TypedExpression KDPgJsonbAdd <T>(TypedExpression array, IEnumerable <object> jsonPath, T item)
{
var pgValue = PgTypesConverter.ConvertObjectToPgValue(item);
return(KDPgJsonbAdd(array, jsonPath, TypedExpression.FromPgValue(pgValue)));
}
public static TypedExpression ArrayRemoveItem <T>(TypedExpression array, T item)
{
var pgValue = PgTypesConverter.ConvertObjectToPgValue(item);
return(ArrayRemoveItem(array, TypedExpression.FromPgValue(pgValue)));
}
public static TypedExpression FromValue(object value)
{
return(FromPgValue(PgTypesConverter.ConvertObjectToPgValue(value)));
}
