小编Joh*_*ica的帖子

我们可以使用运行时包(*.bpl)构建VCL Win32应用程序.这些包可以动态或静态加载和卸载.

我们是否在Delphi XE2中使用新的FireMonkey框架具有类似的开发选项？

我想使用select中的单行生成以下输出.

SELECT max(t1.id)+1 as new_id FROM t1;
-> 101

However I want to do

SELECT s.last_id, sequence(1..100000000) as new_id 
FROM (SELECT max(table1.id)+1 as last_id FROM table1) s;
-> 101,1
-> 101,2
-> 101,3 
......
-> 101,100000000

在postgreSQL中,我可以使用:

SELECT s.last_id, generate_series(1,100000000) 
FROM (SELECT max(table1.id)+1 as last_id FROM table1) s;  -- returns 100,000,000 rows 

如何在不使用临时表的情况下在MySQL中执行此操作？

我正在使用以下代码创建我的第一个函数:

CREATE FUNCTION CTRLPRODUCAO.COMPARATOTAIS (AG INT, P INT, ANO INT)
RETURNS BOOLEAN DETERMINISTIC

BEGIN
    (...)
END

当我运行该命令时,收到了Workbench的返回:"0行受影响".好吗？

当我运行SELECT CTRLPRODUCAO.COMPARATOTAIS(1,9,2011)AS TEST时;

我明白了

"错误代码:1305 FUNCTION CTRLPRODUCAO.COMPARATOTAIS不存在"

我究竟做错了什么？

我正在尝试编写一个简单的firemonkey测试应用程序.

我有一个表单,有一个面板(align:= alClient).
表格上是2 TCircle.我已经设置了TCircle.Dragmode:= dmAutomatic.

我想拖动圆圈并在圆圈重叠时发生一些事情.
问题是:我没有在TCircle中看到任何称为重叠的方法,也没有看到一个名为重叠的事件.我已经尝试了所有的xxxxDrag事件,但这对我的测试没有帮助.

如何查看拖动的形状何时与另一个形状重叠？
我期待的一个DragOver,DragEnter事件检测这对我来说,但是这似乎并不如此.

当然在Firemonkey中必须有一些标准方法吗？

现在pas文件看起来像:

implementation

{$R *.fmx}

procedure TForm8.Circle1DragEnter(Sender: TObject; const Data: TDragObject;
  const Point: TPointF);
begin
  if Data.Source = Circle1 then Button1.Text:= 'DragEnter';

end;

procedure TForm8.Circle1DragOver(Sender: TObject; const Data: TDragObject;
  const Point: TPointF; var Accept: Boolean);
begin
  if (Data.Source = Circle2) then Button1.Text:= 'Circle2 drag';
end;

procedure TForm8.Circle2DragEnd(Sender: TObject);
begin
  Button1.Text:= 'DragEnd';
end;

procedure TForm8.Circle2DragEnter(Sender: TObject; const Data: TDragObject;
  const Point: TPointF);
begin
  Button1.Text:= 'DragEnter';
end; …

嗨伙计们我想尝试做类似的事情

SELECT * from accounttable, peopletable, companytable 
WHERE if accounttable.account_type = company 
JOIN companytable 
WHERE companytable.id = accounttable.company_id 
ELSE IF accounttable.account_type = = person 
JOIN peopletable 
  WHERE peopletable.id = accounttable.person_id

对不起它有点sqlenglish但我真的不知道如何写出来!

我想声明一个通用记录,如下所示:

type
  TMyDelegate<T: constraint> = record
  private
    fDelegate: T;
  public
    class operator Implicit(a: T): TMyDelegate;
    class operator Implicit(A: TMyDelegate: T);
  end;

我想限制T到reference to procedure/function.(越多越好).

我试过这个,但它没有编译:

program Project3;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.SysUtils;

type

  TProc1 = reference to procedure(a: Integer);
  TProc2 = reference to procedure(b: TObject);

  TTest<T: TProc1, TProc2> = record
  private
    fData: T;
  public
    class operator Implicit(a: T): TTest<T>;
    class operator Implicit(a: TTest<T>): T;
  end;

  { TTest<T> }

class operator TTest<T>.Implicit(a: T): TTest<T>;
begin
  Result.fData:= …

我可以很容易地声明枚举和集合.
但有时我只想使用枚举的一部分,我希望编译器检查子枚举及其子集中的值是否保持在边界内.

type
  TDay = (mon, tue, wen, thu, fri, sat, sun);
  TWeekday = (mon..fri); //not allowed;

  TDays = set of TDay;
  TWeekdays = set of TDay[mon..fri]; //not allowed

我可以申报TWeekday并TWeekdays作为TDay的衍生产品,如果是,如何？

_{有趣的是谷歌在这个问题上没有产生任何东西(对我而言),只是普通的老套装.}

我可以使用类操作符来使用中间保持记录.
这样我就可以隐式转换内置类型了.

program TestNewStringHelper; 
{$APPTYPE CONSOLE}
uses
  System.SysUtils;
type
  TStringRecord = record
  private
    Data: string;
  public
    class operator Implicit(const a: TStringRecord): Integer; inline;
    class operator Implicit(const a: string): TStringRecord; inline;
  end;

{ TStringRecord }

class operator TStringRecord.Implicit(const a: string): TStringRecord;
begin
  pointer(Result.Data):= pointer(a);
end;

class operator TStringRecord.Implicit(const a: TStringRecord): Integer;
begin
  Result:= StrToInt(a.Data);
end;

var
  input: TStringRecord;
  output: integer;

begin
  input:= '42';
  output:= input;
  WriteLn(IntToStr(output));
  ReadLn;
end.

我想做一些相反的事情:

var
  input: string;
  output: integer;

begin
  input:= '42';
  output:= input;  //Class operator …

我正在为我的 FastCode 项目编写测试用例。

我写了一个通用测试器，如下所示：

  TTest<T> = record
  private
    class var Def: System.Generics.Defaults.IComparer<T>;
    class var F: FastDefaults.TComparison<T>;
  strict private
    class function Slow(const Left, Right: T): integer; static;
    class function Fast(const Left, Right: T): integer; static;
    class constructor Init;
  public
    class procedure Test(const Left, Right: T); static;
  end;

典型的测试用例如下所示：

[Test]
[TestCase('Single', '100.0,100.0')]
...many more testcases...
procedure TestSingle(const L,R: Single);
[Test]
[TestCase('Double', '100.0,100.0')]
...many more testcases... (identical to the one above).
procedure TestDouble(const L,R: double);

测试代码通常如下（对每种类型重复）：

procedure TestDefault.TestSingle(const L, R: Single);
begin
  TTest<Single>.Test(L,R); …

在 cuda 示例中，例如这里，__match_all_sync __match_any_sync 用来。

这是一个例子，其中一个经线被分成多个（一个或多个）组，每个组都跟踪自己的原子计数器。

// increment the value at ptr by 1 and return the old value
__device__ int atomicAggInc(int* ptr) {
    int pred;
    //const auto mask = __match_all_sync(__activemask(), ptr, &pred); //error, should be any_sync, not all_sync
    const auto mask = __match_any_sync(__activemask(), ptr, &pred);
    const auto leader = __ffs(mask) - 1;  // select a leader
    int res;
    const auto lane_id = ThreadId() % warpSize;
    if (lane_id == leader) {                 // leader does the update
        res …