// save to stream
//------------------------------------------------------------------------------
procedure TMYLDBMetaObjectDef.SaveToStream(Stream: TStream);
var Len: Byte;
begin
  Len := Length(Name);
  SaveDataToStream(Len,Sizeof(Len),Stream,10164);
  SaveDataToStream(PChar(@FName[1])^,Len,Stream,10165);
  SaveDataToStream(FObjectID,sizeof(ObjectID),Stream,10168);
end; // SaveToStream


////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBFieldDef
//
////////////////////////////////////////////////////////////////////////////////



//------------------------------------------------------------------------------
// Constructor
//------------------------------------------------------------------------------
constructor TMYLDBFieldDef.Create;
begin
  inherited Create;
  FBaseFieldType := bftUnknown;
  FAdvancedFieldType := aftUnknown;
  FFieldSize := 0;
  FDiskDataSize := 0;
  FMemoryDataSize := 0;
  FDiskOffset := 0;
  FMemoryOffset := 0;
  FFieldNoReference := 0;

  // Default Value
  //FDefaultValueType := dvtNull;
  FDefaultValue := TMYLDBVariant.Create;
  FDefaultValueExpr := nil;

  // Blob data
  FBLOBCompressionAlgorithm := acaNone;
  FBLOBCompressionMode := 0;
  FBLOBBlockSize := DefaultBLOBBlockSize;

  // Autoinc settings
  FAutoincIncrement := 1;
  FAutoincInitialValue := 0;
  FAutoincMinValue  := 0;//Low(Int64);
  FAutoincMaxValue  := High(Int64);
  FAutoincCycled    := False;

end;//Create


//------------------------------------------------------------------------------
// Destroy
//------------------------------------------------------------------------------
destructor TMYLDBFieldDef.Destroy;
begin
  FDefaultValue.Free;
  if (FDefaultValueExpr <> nil) then
    FDefaultValueExpr.Free;
  inherited;
end;//Destroy


//------------------------------------------------------------------------------
// SetFieldDefData ( set Advanced Field Type )
//------------------------------------------------------------------------------
procedure TMYLDBFieldDef.SetFieldDefDataType(AdvancedFieldType: TMYLDBAdvancedFieldType;
                                           FieldSize: Integer);
begin
  FAdvancedFieldType := AdvancedFieldType;
  FBaseFieldType := AdvancedFieldTypeToBaseFieldType(AdvancedFieldType);
  if FBaseFieldType = bftUnknown then
   raise EMYLDBException.Create(30007,ErrorGUnsupportedDataType,
                                    [AftToStr(AdvancedFieldType)]);
  FFieldSize := FieldSize;
  RecalcInternalSizes;
end;//SetFieldDefData


//------------------------------------------------------------------------------
// SetFieldDefData ( set Advanced Field Type )
//------------------------------------------------------------------------------
procedure TMYLDBFieldDef.SetFieldDefDataType(BaseFieldType: TMYLDBBaseFieldType;
                                           FieldSize: Integer);
begin
  FBaseFieldType := BaseFieldType;
  FFieldSize := FieldSize;

  FAdvancedFieldType := BaseFieldTypeToAdvancedFieldType(BaseFieldType);
  if FAdvancedFieldType = aftUnknown then
   raise EMYLDBException.Create(30008,ErrorGUnsupportedDataType,
                                    [BftToStr(BaseFieldType)]);
  RecalcInternalSizes;
end;//SetFieldDefData



//------------------------------------------------------------------------------
// RecalcInternalSizes
//------------------------------------------------------------------------------
procedure TMYLDBFieldDef.RecalcInternalSizes;
begin
  // FMemoryDataSize ...
  FMemoryDataSize := GetDataSizeInMemory(FBaseFieldType, FFieldSize);

  // FDiskDataSize ...
  if IsBLOBFieldType(FBaseFieldType) then
   FDiskDataSize := SizeOf(TMYLDBPageItemID)
  else
   FDiskDataSize := FMemoryDataSize;
end;//RecalcInternalSizes


//------------------------------------------------------------------------------
// CreateDefaultValueExprIfNeeded
//------------------------------------------------------------------------------
procedure TMYLDBFieldDef.CreateDefaultValueExprIfNeeded;
begin
  if (FDefaultValueExpr <> nil) then
    begin
      FDefaultValueExpr.Free;
      FDefaultValueExpr := nil;
    end;
  if (IsNonConstantExpression(FDefaultValue)) then
    begin
      FDefaultValueExpr := TMYLDBExpression.Create;
      TMYLDBExpression(FDefaultValueExpr).ParseForDefaultValueExpression(FDefaultValue.AsString);
    end;
end;// CreateDefaultValueExprIfNeeded


//------------------------------------------------------------------------------
// Assign
//------------------------------------------------------------------------------
procedure TMYLDBFieldDef.Assign(Source: TMYLDBMetaObjectDef);
var s: TMYLDBFieldDef;
begin
  s := Source as TMYLDBFieldDef;
  inherited Assign(Source);
  FBaseFieldType := s.FBaseFieldType;
  FAdvancedFieldType := s.FAdvancedFieldType;
  FFieldSize := s.FFieldSize;
  FDiskDataSize := s.FDiskDataSize;
  FMemoryDataSize := s.FMemoryDataSize;
  FDiskOffset := s.FDiskOffset;
  FMemoryOffset := s.FMemoryOffset;

  // Default Value
  //FDefaultValueType := s.FDefaultValueType;
  FDefaultValue.Assign(s.FDefaultValue);
  CreateDefaultValueExprIfNeeded;

  // Blob data
  FBLOBCompressionAlgorithm := s.FBLOBCompressionAlgorithm;
  FBLOBCompressionMode      := s.FBLOBCompressionMode;
  FBLOBBlockSize            := s.FBLOBBlockSize;

  // Autoinc settings
  FAutoincIncrement := s.FAutoincIncrement;
  FAutoincInitialValue := s.FAutoincInitialValue;
  FAutoincMinValue  := s.FAutoincMinValue;
  FAutoincMaxValue  := s.FAutoincMaxValue;
  FAutoincCycled    := s.FAutoincCycled;

end;//Assign


//------------------------------------------------------------------------------
// load from stream
//------------------------------------------------------------------------------
procedure TMYLDBFieldDef.LoadFromStream(Stream: TStream);
begin
  inherited LoadFromStream(Stream);

  LoadDataFromStream(FBaseFieldType,Sizeof(FBaseFieldType),Stream,10187);
  LoadDataFromStream(FAdvancedFieldType,Sizeof(FAdvancedFieldType),Stream,10188);
  LoadDataFromStream(FFieldSize,Sizeof(FFieldSize),Stream,10189);

  FDefaultValue.SetNull(FBaseFieldType);
  if (IsBlobFieldType(FBaseFieldType)) then
   begin
    // load blob params
    LoadDataFromStream(FBLOBCompressionAlgorithm,Sizeof(FBLOBCompressionAlgorithm),Stream,10192);
    LoadDataFromStream(FBLOBCompressionMode,Sizeof(FBLOBCompressionMode),Stream,10193);
    LoadDataFromStream(FBLOBBlockSize,Sizeof(FBLOBBlockSize),Stream,10194);
   end;

   LoadDataFromStream(FAutoincIncrement,Sizeof(FAutoincIncrement),Stream,30407);
   LoadDataFromStream(FAutoincInitialValue,Sizeof(FAutoincInitialValue),Stream,30408);
   LoadDataFromStream(FAutoincMinValue,Sizeof(FAutoincMinValue),Stream,30409);
   LoadDataFromStream(FAutoincMaxValue,Sizeof(FAutoincMaxValue),Stream,30410);
   LoadDataFromStream(FAutoincCycled,Sizeof(FAutoincCycled),Stream,30411);

   // load default value
   FDefaultValue.LoadFromStream(Stream);
   CreateDefaultValueExprIfNeeded;

   RecalcInternalSizes;
end; // LoadFromStream


//------------------------------------------------------------------------------
// save to stream
//------------------------------------------------------------------------------
procedure TMYLDBFieldDef.SaveToStream(Stream: TStream);
begin
  inherited SaveToStream(Stream);

  SaveDataToStream(FBaseFieldType,Sizeof(FBaseFieldType),Stream,10170);
  SaveDataToStream(FAdvancedFieldType,Sizeof(FAdvancedFieldType),Stream,10171);
  SaveDataToStream(FFieldSize,Sizeof(FFieldSize),Stream,10172);

  if (IsBlobFieldType(FBaseFieldType)) then
   begin
    // save blob params
    SaveDataToStream(FBLOBCompressionAlgorithm,Sizeof(FBLOBCompressionAlgorithm),Stream,10175);
    SaveDataToStream(FBLOBCompressionMode,Sizeof(FBLOBCompressionMode),Stream,10176);
    SaveDataToStream(FBLOBBlockSize,Sizeof(FBLOBBlockSize),Stream,10177);
   end;

   SaveDataToStream(FAutoincIncrement,Sizeof(FAutoincIncrement),Stream,30412);
   SaveDataToStream(FAutoincInitialValue,Sizeof(FAutoincInitialValue),Stream,30413);
   SaveDataToStream(FAutoincMinValue,Sizeof(FAutoincMinValue),Stream,30414);
   SaveDataToStream(FAutoincMaxValue,Sizeof(FAutoincMaxValue),Stream,30415);
   SaveDataToStream(FAutoincCycled,Sizeof(FAutoincCycled),Stream,30416);

   // save default value
   FDefaultValue.SaveToStream(Stream);

end; // SaveToStream


////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBIndexColumn
//
////////////////////////////////////////////////////////////////////////////////


//------------------------------------------------------------------------------
// load from stream
//------------------------------------------------------------------------------
procedure TMYLDBIndexColumn.LoadFromStream(Stream: TStream);
var Len: Byte;
begin
  LoadDataFromStream(Len,Sizeof(Len),Stream,10358);
  SetLength(FFieldName,Len);
  LoadDataFromStream(PChar(@FFieldName[1])^,Len,Stream,10359);
  LoadDataFromStream(FDescending,Sizeof(FDescending),Stream,10360);
  LoadDataFromStream(FCaseInsensitive,Sizeof(FCaseInsensitive),Stream,10361);
  LoadDataFromStream(FMaxIndexedSize,Sizeof(FMaxIndexedSize),Stream,20168);
end; // LoadFromStream


//------------------------------------------------------------------------------
// save to stream
//------------------------------------------------------------------------------
procedure TMYLDBIndexColumn.SaveToStream(Stream: TStream);
var Len: Byte;
begin
  Len := Length(FFieldName);
  SaveDataToStream(Len,Sizeof(Len),Stream,10354);
  SaveDataToStream(PChar(@FFieldName[1])^,Len,Stream,10355);
  SaveDataToStream(FDescending,Sizeof(FDescending),Stream,10356);
  SaveDataToStream(FCaseInsensitive,Sizeof(FCaseInsensitive),Stream,10357);
  SaveDataToStream(FMaxIndexedSize,Sizeof(FMaxIndexedSize),Stream,20169);
end; // SaveToStream


////////////////////////////////////////////////////////////////////////////////
//
// TMYLDBIndexDef
//
////////////////////////////////////////////////////////////////////////////////


//------------------------------------------------------------------------------
// get index column
//------------------------------------------------------------------------------
function TMYLDBIndexDef.GetIndexColumn(Index: Integer): TMYLDBIndexColumn;
begin
  Result := FIndexColumns[Index];
end;// GetIndexColumn


//------------------------------------------------------------------------------
// get column count
//------------------------------------------------------------------------------
function TMYLDBIndexDef.GetColumnCount: Integer;
begin
  Result := Length(FIndexColumns);
end;// GetColumnCount


//------------------------------------------------------------------------------
// set column count
//------------------------------------------------------------------------------
procedure TMYLDBIndexDef.SetColumnCount(Value: Integer);
var
  oldCount, i: Integer;
begin
  oldCount := Length(FIndexColumns);
  if (Value > oldCount) then
   begin
     SetLength(FIndexColumns, Value);
     for i := oldCount to Value-1 do
      FIndexColumns[i] := TMYLDBIndexColumn.Create;
   end
  else
  if (Value < oldCount) then
   begin
     for i := Value to oldCount-1 do
      FIndexColumns[i].Free;
     SetLength(FIndexColumns, Value);
   end;
end;// SetColumnCount




//------------------------------------------------------------------------------